io_u.c

   1 #include <unistd.h>
   2 #include <fcntl.h>
   3 #include <string.h>
   4 #include <signal.h>
   5 #include <time.h>
   6 #include <assert.h>
   7
   8 #include "fio.h"
   9 #include "hash.h"
  10 #include "verify.h"
  11 #include "trim.h"
  12 #include "lib/rand.h"
  13
  14 struct io_completion_data {
  15         int nr;                         /* input */
  16
  17         int error;                      /* output */
  18         unsigned long bytes_done[2];    /* output */
  19         struct timeval time;            /* output */
  20 };
  21
  22 /*
  23  * The ->file_map[] contains a map of blocks we have or have not done io
  24  * to yet. Used to make sure we cover the entire range in a fair fashion.
  25  */
  26 static int random_map_free(struct fio_file *f, const unsigned long long block)
  27 {
  28         unsigned int idx = RAND_MAP_IDX(f, block);
  29         unsigned int bit = RAND_MAP_BIT(f, block);
  30
  31         dprint(FD_RANDOM, "free: b=%llu, idx=%u, bit=%u\n", block, idx, bit);
  32
  33         return (f->file_map[idx] & (1UL << bit)) == 0;
  34 }
  35
  36 /*
  37  * Mark a given offset as used in the map.
  38  */
  39 static void mark_random_map(struct thread_data *td, struct io_u *io_u)
  40 {
  41         unsigned int min_bs = td->o.rw_min_bs;
  42         struct fio_file *f = io_u->file;
  43         unsigned long long block;
  44         unsigned int blocks, nr_blocks;
  45         int busy_check;
  46
  47         block = (io_u->offset - f->file_offset) / (unsigned long long) min_bs;
  48         nr_blocks = (io_u->buflen + min_bs - 1) / min_bs;
  49         blocks = 0;
  50         busy_check = !(io_u->flags & IO_U_F_BUSY_OK);
  51
  52         while (nr_blocks) {
  53                 unsigned int idx, bit;
  54                 unsigned long mask, this_blocks;
  55
  56                 /*
  57                  * If we have a mixed random workload, we may
  58                  * encounter blocks we already did IO to.
  59                  */
  60                 if (!busy_check) {
  61                         blocks = nr_blocks;
  62                         break;
  63                 }
  64                 if ((td->o.ddir_seq_nr == 1) && !random_map_free(f, block))
  65                         break;
  66
  67                 idx = RAND_MAP_IDX(f, block);
  68                 bit = RAND_MAP_BIT(f, block);
  69
  70                 fio_assert(td, idx < f->num_maps);
  71
  72                 this_blocks = nr_blocks;
  73                 if (this_blocks + bit > BLOCKS_PER_MAP)
  74                         this_blocks = BLOCKS_PER_MAP - bit;
  75
  76                 do {
  77                         if (this_blocks == BLOCKS_PER_MAP)
  78                                 mask = -1UL;
  79                         else
  80                                 mask = ((1UL << this_blocks) - 1) << bit;
  81
  82                         if (!(f->file_map[idx] & mask))
  83                                 break;
  84
  85                         this_blocks--;
  86                 } while (this_blocks);
  87
  88                 if (!this_blocks)
  89                         break;
  90
  91                 f->file_map[idx] |= mask;
  92                 nr_blocks -= this_blocks;
  93                 blocks += this_blocks;
  94                 block += this_blocks;
  95         }
  96
  97         if ((blocks * min_bs) < io_u->buflen)
  98                 io_u->buflen = blocks * min_bs;
  99 }
 100
 101 static unsigned long long last_block(struct thread_data *td, struct fio_file *f,
 102                                      enum fio_ddir ddir)
 103 {
 104         unsigned long long max_blocks;
 105         unsigned long long max_size;
 106
 107         assert(ddir_rw(ddir));
 108
 109         /*
 110          * Hmm, should we make sure that ->io_size <= ->real_file_size?
 111          */
 112         max_size = f->io_size;
 113         if (max_size > f->real_file_size)
 114                 max_size = f->real_file_size;
 115
 116         max_blocks = max_size / (unsigned long long) td->o.ba[ddir];
 117         if (!max_blocks)
 118                 return 0;
 119
 120         return max_blocks;
 121 }
 122
 123 /*
 124  * Return the next free block in the map.
 125  */
 126 static int get_next_free_block(struct thread_data *td, struct fio_file *f,
 127                                enum fio_ddir ddir, unsigned long long *b)
 128 {
 129         unsigned long long block, min_bs = td->o.rw_min_bs, lastb;
 130         int i;
 131
 132         lastb = last_block(td, f, ddir);
 133         if (!lastb)
 134                 return 1;
 135
 136         i = f->last_free_lookup;
 137         block = i * BLOCKS_PER_MAP;
 138         while (block * min_bs < f->real_file_size &&
 139                 block * min_bs < f->io_size) {
 140                 if (f->file_map[i] != -1UL) {
 141                         block += ffz(f->file_map[i]);
 142                         if (block > lastb)
 143                                 break;
 144                         f->last_free_lookup = i;
 145                         *b = block;
 146                         return 0;
 147                 }
 148
 149                 block += BLOCKS_PER_MAP;
 150                 i++;
 151         }
 152
 153         dprint(FD_IO, "failed finding a free block\n");
 154         return 1;
 155 }
 156
 157 static int get_next_rand_offset(struct thread_data *td, struct fio_file *f,
 158                                 enum fio_ddir ddir, unsigned long long *b)
 159 {
 160         unsigned long long r, lastb;
 161         int loops = 5;
 162
 163         lastb = last_block(td, f, ddir);
 164         if (!lastb)
 165                 return 1;
 166
 167         if (f->failed_rands >= 200)
 168                 goto ffz;
 169
 170         do {
 171                 if (td->o.use_os_rand) {
 172                         r = os_random_long(&td->random_state);
 173                         *b = (lastb - 1) * (r / ((unsigned long long) OS_RAND_MAX + 1.0));
 174                 } else {
 175                         r = __rand(&td->__random_state);
 176                         *b = (lastb - 1) * (r / ((unsigned long long) FRAND_MAX + 1.0));
 177                 }
 178
 179                 dprint(FD_RANDOM, "off rand %llu\n", r);
 180
 181
 182                 /*
 183                  * if we are not maintaining a random map, we are done.
 184                  */
 185                 if (!file_randommap(td, f))
 186                         goto ret_good;
 187
 188                 /*
 189                  * calculate map offset and check if it's free
 190                  */
 191                 if (random_map_free(f, *b))
 192                         goto ret_good;
 193
 194                 dprint(FD_RANDOM, "get_next_rand_offset: offset %llu busy\n",
 195                                                                         *b);
 196         } while (--loops);
 197
 198         if (!f->failed_rands++)
 199                 f->last_free_lookup = 0;
 200
 201         /*
 202          * we get here, if we didn't suceed in looking up a block. generate
 203          * a random start offset into the filemap, and find the first free
 204          * block from there.
 205          */
 206         loops = 10;
 207         do {
 208                 f->last_free_lookup = (f->num_maps - 1) *
 209                                         (r / (OS_RAND_MAX + 1.0));
 210                 if (!get_next_free_block(td, f, ddir, b))
 211                         goto ret;
 212
 213                 if (td->o.use_os_rand)
 214                         r = os_random_long(&td->random_state);
 215                 else
 216                         r = __rand(&td->__random_state);
 217         } while (--loops);
 218
 219         /*
 220          * that didn't work either, try exhaustive search from the start
 221          */
 222         f->last_free_lookup = 0;
 223 ffz:
 224         if (!get_next_free_block(td, f, ddir, b))
 225                 return 0;
 226         f->last_free_lookup = 0;
 227         return get_next_free_block(td, f, ddir, b);
 228 ret_good:
 229         f->failed_rands = 0;
 230 ret:
 231         return 0;
 232 }
 233
 234 static int get_next_rand_block(struct thread_data *td, struct fio_file *f,
 235                                enum fio_ddir ddir, unsigned long long *b)
 236 {
 237         if (get_next_rand_offset(td, f, ddir, b)) {
 238                 dprint(FD_IO, "%s: rand offset failed, last=%llu, size=%llu\n",
 239                                 f->file_name, f->last_pos, f->real_file_size);
 240                 return 1;
 241         }
 242
 243         return 0;
 244 }
 245
 246 static int get_next_seq_block(struct thread_data *td, struct fio_file *f,
 247                               enum fio_ddir ddir, unsigned long long *b)
 248 {
 249         assert(ddir_rw(ddir));
 250
 251         if (f->last_pos < f->real_file_size) {
 252                 unsigned long long pos;
 253
 254                 if (f->last_pos == f->file_offset && td->o.ddir_seq_add < 0)
 255                         f->last_pos = f->real_file_size;
 256
 257                 pos = f->last_pos - f->file_offset;
 258                 if (pos)
 259                         pos += td->o.ddir_seq_add;
 260
 261                 *b = pos / td->o.min_bs[ddir];
 262                 return 0;
 263         }
 264
 265         return 1;
 266 }
 267
 268 static int get_next_block(struct thread_data *td, struct io_u *io_u,
 269                           enum fio_ddir ddir, int rw_seq, unsigned long long *b)
 270 {
 271         struct fio_file *f = io_u->file;
 272         int ret;
 273
 274         assert(ddir_rw(ddir));
 275
 276         if (rw_seq) {
 277                 if (td_random(td))
 278                         ret = get_next_rand_block(td, f, ddir, b);
 279                 else
 280                         ret = get_next_seq_block(td, f, ddir, b);
 281         } else {
 282                 io_u->flags |= IO_U_F_BUSY_OK;
 283
 284                 if (td->o.rw_seq == RW_SEQ_SEQ) {
 285                         ret = get_next_seq_block(td, f, ddir, b);
 286                         if (ret)
 287                                 ret = get_next_rand_block(td, f, ddir, b);
 288                 } else if (td->o.rw_seq == RW_SEQ_IDENT) {
 289                         if (f->last_start != -1ULL)
 290                                 *b = (f->last_start - f->file_offset)
 291                                         / td->o.min_bs[ddir];
 292                         else
 293                                 *b = 0;
 294                         ret = 0;
 295                 } else {
 296                         log_err("fio: unknown rw_seq=%d\n", td->o.rw_seq);
 297                         ret = 1;
 298                 }
 299         }
 300
 301         return ret;
 302 }
 303
 304 /*
 305  * For random io, generate a random new block and see if it's used. Repeat
 306  * until we find a free one. For sequential io, just return the end of
 307  * the last io issued.
 308  */
 309 static int __get_next_offset(struct thread_data *td, struct io_u *io_u)
 310 {
 311         struct fio_file *f = io_u->file;
 312         unsigned long long b;
 313         enum fio_ddir ddir = io_u->ddir;
 314         int rw_seq_hit = 0;
 315
 316         assert(ddir_rw(ddir));
 317
 318         if (td->o.ddir_seq_nr && !--td->ddir_seq_nr) {
 319                 rw_seq_hit = 1;
 320                 td->ddir_seq_nr = td->o.ddir_seq_nr;
 321         }
 322
 323         if (get_next_block(td, io_u, ddir, rw_seq_hit, &b))
 324                 return 1;
 325
 326         io_u->offset = b * td->o.ba[ddir];
 327         if (io_u->offset >= f->io_size) {
 328                 dprint(FD_IO, "get_next_offset: offset %llu >= io_size %llu\n",
 329                                         io_u->offset, f->io_size);
 330                 return 1;
 331         }
 332
 333         io_u->offset += f->file_offset;
 334         if (io_u->offset >= f->real_file_size) {
 335                 dprint(FD_IO, "get_next_offset: offset %llu >= size %llu\n",
 336                                         io_u->offset, f->real_file_size);
 337                 return 1;
 338         }
 339
 340         return 0;
 341 }
 342
 343 static int get_next_offset(struct thread_data *td, struct io_u *io_u)
 344 {
 345         struct prof_io_ops *ops = &td->prof_io_ops;
 346
 347         if (ops->fill_io_u_off)
 348                 return ops->fill_io_u_off(td, io_u);
 349
 350         return __get_next_offset(td, io_u);
 351 }
 352
 353 static inline int io_u_fits(struct thread_data *td, struct io_u *io_u,
 354                             unsigned int buflen)
 355 {
 356         struct fio_file *f = io_u->file;
 357
 358         return io_u->offset + buflen <= f->io_size + td->o.start_offset;
 359 }
 360
 361 static unsigned int __get_next_buflen(struct thread_data *td, struct io_u *io_u)
 362 {
 363         const int ddir = io_u->ddir;
 364         unsigned int uninitialized_var(buflen);
 365         unsigned int minbs, maxbs;
 366         unsigned long r, rand_max;
 367
 368         assert(ddir_rw(ddir));
 369
 370         minbs = td->o.min_bs[ddir];
 371         maxbs = td->o.max_bs[ddir];
 372
 373         if (minbs == maxbs)
 374                 return minbs;
 375
 376         if (td->o.use_os_rand)
 377                 rand_max = OS_RAND_MAX;
 378         else
 379                 rand_max = FRAND_MAX;
 380
 381         do {
 382                 if (td->o.use_os_rand)
 383                         r = os_random_long(&td->bsrange_state);
 384                 else
 385                         r = __rand(&td->__bsrange_state);
 386
 387                 if (!td->o.bssplit_nr[ddir]) {
 388                         buflen = 1 + (unsigned int) ((double) maxbs *
 389                                         (r / (rand_max + 1.0)));
 390                         if (buflen < minbs)
 391                                 buflen = minbs;
 392                 } else {
 393                         long perc = 0;
 394                         unsigned int i;
 395
 396                         for (i = 0; i < td->o.bssplit_nr[ddir]; i++) {
 397                                 struct bssplit *bsp = &td->o.bssplit[ddir][i];
 398
 399                                 buflen = bsp->bs;
 400                                 perc += bsp->perc;
 401                                 if ((r <= ((rand_max / 100L) * perc)) &&
 402                                     io_u_fits(td, io_u, buflen))
 403                                         break;
 404                         }
 405                 }
 406
 407                 if (!td->o.bs_unaligned && is_power_of_2(minbs))
 408                         buflen = (buflen + minbs - 1) & ~(minbs - 1);
 409
 410         } while (!io_u_fits(td, io_u, buflen));
 411
 412         return buflen;
 413 }
 414
 415 static unsigned int get_next_buflen(struct thread_data *td, struct io_u *io_u)
 416 {
 417         struct prof_io_ops *ops = &td->prof_io_ops;
 418
 419         if (ops->fill_io_u_size)
 420                 return ops->fill_io_u_size(td, io_u);
 421
 422         return __get_next_buflen(td, io_u);
 423 }
 424
 425 static void set_rwmix_bytes(struct thread_data *td)
 426 {
 427         unsigned int diff;
 428
 429         /*
 430          * we do time or byte based switch. this is needed because
 431          * buffered writes may issue a lot quicker than they complete,
 432          * whereas reads do not.
 433          */
 434         diff = td->o.rwmix[td->rwmix_ddir ^ 1];
 435         td->rwmix_issues = (td->io_issues[td->rwmix_ddir] * diff) / 100;
 436 }
 437
 438 static inline enum fio_ddir get_rand_ddir(struct thread_data *td)
 439 {
 440         unsigned int v;
 441         unsigned long r;
 442
 443         if (td->o.use_os_rand) {
 444                 r = os_random_long(&td->rwmix_state);
 445                 v = 1 + (int) (100.0 * (r / (OS_RAND_MAX + 1.0)));
 446         } else {
 447                 r = __rand(&td->__rwmix_state);
 448                 v = 1 + (int) (100.0 * (r / (FRAND_MAX + 1.0)));
 449         }
 450
 451         if (v <= td->o.rwmix[DDIR_READ])
 452                 return DDIR_READ;
 453
 454         return DDIR_WRITE;
 455 }
 456
 457 static enum fio_ddir rate_ddir(struct thread_data *td, enum fio_ddir ddir)
 458 {
 459         enum fio_ddir odir = ddir ^ 1;
 460         struct timeval t;
 461         long usec;
 462
 463         assert(ddir_rw(ddir));
 464
 465         if (td->rate_pending_usleep[ddir] <= 0)
 466                 return ddir;
 467
 468         /*
 469          * We have too much pending sleep in this direction. See if we
 470          * should switch.
 471          */
 472         if (td_rw(td)) {
 473                 /*
 474                  * Other direction does not have too much pending, switch
 475                  */
 476                 if (td->rate_pending_usleep[odir] < 100000)
 477                         return odir;
 478
 479                 /*
 480                  * Both directions have pending sleep. Sleep the minimum time
 481                  * and deduct from both.
 482                  */
 483                 if (td->rate_pending_usleep[ddir] <=
 484                         td->rate_pending_usleep[odir]) {
 485                         usec = td->rate_pending_usleep[ddir];
 486                 } else {
 487                         usec = td->rate_pending_usleep[odir];
 488                         ddir = odir;
 489                 }
 490         } else
 491                 usec = td->rate_pending_usleep[ddir];
 492
 493         /*
 494          * We are going to sleep, ensure that we flush anything pending as
 495          * not to skew our latency numbers
 496          */
 497         if (td->cur_depth) {
 498                 int fio_unused ret;
 499
 500                 ret = io_u_queued_complete(td, td->cur_depth, NULL);
 501         }
 502
 503         fio_gettime(&t, NULL);
 504         usec_sleep(td, usec);
 505         usec = utime_since_now(&t);
 506
 507         td->rate_pending_usleep[ddir] -= usec;
 508
 509         odir = ddir ^ 1;
 510         if (td_rw(td) && __should_check_rate(td, odir))
 511                 td->rate_pending_usleep[odir] -= usec;
 512
 513         return ddir;
 514 }
 515
 516 /*
 517  * Return the data direction for the next io_u. If the job is a
 518  * mixed read/write workload, check the rwmix cycle and switch if
 519  * necessary.
 520  */
 521 static enum fio_ddir get_rw_ddir(struct thread_data *td)
 522 {
 523         enum fio_ddir ddir;
 524
 525         /*
 526          * see if it's time to fsync
 527          */
 528         if (td->o.fsync_blocks &&
 529            !(td->io_issues[DDIR_WRITE] % td->o.fsync_blocks) &&
 530              td->io_issues[DDIR_WRITE] && should_fsync(td))
 531                 return DDIR_SYNC;
 532
 533         /*
 534          * see if it's time to fdatasync
 535          */
 536         if (td->o.fdatasync_blocks &&
 537            !(td->io_issues[DDIR_WRITE] % td->o.fdatasync_blocks) &&
 538              td->io_issues[DDIR_WRITE] && should_fsync(td))
 539                 return DDIR_DATASYNC;
 540
 541         /*
 542          * see if it's time to sync_file_range
 543          */
 544         if (td->sync_file_range_nr &&
 545            !(td->io_issues[DDIR_WRITE] % td->sync_file_range_nr) &&
 546              td->io_issues[DDIR_WRITE] && should_fsync(td))
 547                 return DDIR_SYNC_FILE_RANGE;
 548
 549         if (td_rw(td)) {
 550                 /*
 551                  * Check if it's time to seed a new data direction.
 552                  */
 553                 if (td->io_issues[td->rwmix_ddir] >= td->rwmix_issues) {
 554                         /*
 555                          * Put a top limit on how many bytes we do for
 556                          * one data direction, to avoid overflowing the
 557                          * ranges too much
 558                          */
 559                         ddir = get_rand_ddir(td);
 560
 561                         if (ddir != td->rwmix_ddir)
 562                                 set_rwmix_bytes(td);
 563
 564                         td->rwmix_ddir = ddir;
 565                 }
 566                 ddir = td->rwmix_ddir;
 567         } else if (td_read(td))
 568                 ddir = DDIR_READ;
 569         else
 570                 ddir = DDIR_WRITE;
 571
 572         td->rwmix_ddir = rate_ddir(td, ddir);
 573         return td->rwmix_ddir;
 574 }
 575
 576 static void set_rw_ddir(struct thread_data *td, struct io_u *io_u)
 577 {
 578         io_u->ddir = get_rw_ddir(td);
 579
 580         if (io_u->ddir == DDIR_WRITE && (td->io_ops->flags & FIO_BARRIER) &&
 581             td->o.barrier_blocks &&
 582            !(td->io_issues[DDIR_WRITE] % td->o.barrier_blocks) &&
 583              td->io_issues[DDIR_WRITE])
 584                 io_u->flags |= IO_U_F_BARRIER;
 585 }
 586
 587 void put_file_log(struct thread_data *td, struct fio_file *f)
 588 {
 589         int ret = put_file(td, f);
 590
 591         if (ret)
 592                 td_verror(td, ret, "file close");
 593 }
 594
 595 void put_io_u(struct thread_data *td, struct io_u *io_u)
 596 {
 597         td_io_u_lock(td);
 598
 599         io_u->flags |= IO_U_F_FREE;
 600         io_u->flags &= ~IO_U_F_FREE_DEF;
 601
 602         if (io_u->file)
 603                 put_file_log(td, io_u->file);
 604
 605         io_u->file = NULL;
 606         if (io_u->flags & IO_U_F_IN_CUR_DEPTH)
 607                 td->cur_depth--;
 608         flist_del_init(&io_u->list);
 609         flist_add(&io_u->list, &td->io_u_freelist);
 610         td_io_u_unlock(td);
 611         td_io_u_free_notify(td);
 612 }
 613
 614 void clear_io_u(struct thread_data *td, struct io_u *io_u)
 615 {
 616         io_u->flags &= ~IO_U_F_FLIGHT;
 617         put_io_u(td, io_u);
 618 }
 619
 620 void requeue_io_u(struct thread_data *td, struct io_u **io_u)
 621 {
 622         struct io_u *__io_u = *io_u;
 623
 624         dprint(FD_IO, "requeue %p\n", __io_u);
 625
 626         td_io_u_lock(td);
 627
 628         __io_u->flags |= IO_U_F_FREE;
 629         if ((__io_u->flags & IO_U_F_FLIGHT) && ddir_rw(__io_u->ddir))
 630                 td->io_issues[__io_u->ddir]--;
 631
 632         __io_u->flags &= ~IO_U_F_FLIGHT;
 633         if (__io_u->flags & IO_U_F_IN_CUR_DEPTH)
 634                 td->cur_depth--;
 635         flist_del(&__io_u->list);
 636         flist_add_tail(&__io_u->list, &td->io_u_requeues);
 637         td_io_u_unlock(td);
 638         *io_u = NULL;
 639 }
 640
 641 static int fill_io_u(struct thread_data *td, struct io_u *io_u)
 642 {
 643         if (td->io_ops->flags & FIO_NOIO)
 644                 goto out;
 645
 646         set_rw_ddir(td, io_u);
 647
 648         /*
 649          * fsync() or fdatasync() or trim etc, we are done
 650          */
 651         if (!ddir_rw(io_u->ddir))
 652                 goto out;
 653
 654         /*
 655          * See if it's time to switch to a new zone
 656          */
 657         if (td->zone_bytes >= td->o.zone_size) {
 658                 td->zone_bytes = 0;
 659                 io_u->file->last_pos += td->o.zone_skip;
 660                 td->io_skip_bytes += td->o.zone_skip;
 661         }
 662
 663         /*
 664          * No log, let the seq/rand engine retrieve the next buflen and
 665          * position.
 666          */
 667         if (get_next_offset(td, io_u)) {
 668                 dprint(FD_IO, "io_u %p, failed getting offset\n", io_u);
 669                 return 1;
 670         }
 671
 672         io_u->buflen = get_next_buflen(td, io_u);
 673         if (!io_u->buflen) {
 674                 dprint(FD_IO, "io_u %p, failed getting buflen\n", io_u);
 675                 return 1;
 676         }
 677
 678         if (io_u->offset + io_u->buflen > io_u->file->real_file_size) {
 679                 dprint(FD_IO, "io_u %p, offset too large\n", io_u);
 680                 dprint(FD_IO, "  off=%llu/%lu > %llu\n", io_u->offset,
 681                                 io_u->buflen, io_u->file->real_file_size);
 682                 return 1;
 683         }
 684
 685         /*
 686          * mark entry before potentially trimming io_u
 687          */
 688         if (td_random(td) && file_randommap(td, io_u->file))
 689                 mark_random_map(td, io_u);
 690
 691         /*
 692          * If using a write iolog, store this entry.
 693          */
 694 out:
 695         dprint_io_u(io_u, "fill_io_u");
 696         td->zone_bytes += io_u->buflen;
 697         log_io_u(td, io_u);
 698         return 0;
 699 }
 700
 701 static void __io_u_mark_map(unsigned int *map, unsigned int nr)
 702 {
 703         int idx = 0;
 704
 705         switch (nr) {
 706         default:
 707                 idx = 6;
 708                 break;
 709         case 33 ... 64:
 710                 idx = 5;
 711                 break;
 712         case 17 ... 32:
 713                 idx = 4;
 714                 break;
 715         case 9 ... 16:
 716                 idx = 3;
 717                 break;
 718         case 5 ... 8:
 719                 idx = 2;
 720                 break;
 721         case 1 ... 4:
 722                 idx = 1;
 723         case 0:
 724                 break;
 725         }
 726
 727         map[idx]++;
 728 }
 729
 730 void io_u_mark_submit(struct thread_data *td, unsigned int nr)
 731 {
 732         __io_u_mark_map(td->ts.io_u_submit, nr);
 733         td->ts.total_submit++;
 734 }
 735
 736 void io_u_mark_complete(struct thread_data *td, unsigned int nr)
 737 {
 738         __io_u_mark_map(td->ts.io_u_complete, nr);
 739         td->ts.total_complete++;
 740 }
 741
 742 void io_u_mark_depth(struct thread_data *td, unsigned int nr)
 743 {
 744         int idx = 0;
 745
 746         switch (td->cur_depth) {
 747         default:
 748                 idx = 6;
 749                 break;
 750         case 32 ... 63:
 751                 idx = 5;
 752                 break;
 753         case 16 ... 31:
 754                 idx = 4;
 755                 break;
 756         case 8 ... 15:
 757                 idx = 3;
 758                 break;
 759         case 4 ... 7:
 760                 idx = 2;
 761                 break;
 762         case 2 ... 3:
 763                 idx = 1;
 764         case 1:
 765                 break;
 766         }
 767
 768         td->ts.io_u_map[idx] += nr;
 769 }
 770
 771 static void io_u_mark_lat_usec(struct thread_data *td, unsigned long usec)
 772 {
 773         int idx = 0;
 774
 775         assert(usec < 1000);
 776
 777         switch (usec) {
 778         case 750 ... 999:
 779                 idx = 9;
 780                 break;
 781         case 500 ... 749:
 782                 idx = 8;
 783                 break;
 784         case 250 ... 499:
 785                 idx = 7;
 786                 break;
 787         case 100 ... 249:
 788                 idx = 6;
 789                 break;
 790         case 50 ... 99:
 791                 idx = 5;
 792                 break;
 793         case 20 ... 49:
 794                 idx = 4;
 795                 break;
 796         case 10 ... 19:
 797                 idx = 3;
 798                 break;
 799         case 4 ... 9:
 800                 idx = 2;
 801                 break;
 802         case 2 ... 3:
 803                 idx = 1;
 804         case 0 ... 1:
 805                 break;
 806         }
 807
 808         assert(idx < FIO_IO_U_LAT_U_NR);
 809         td->ts.io_u_lat_u[idx]++;
 810 }
 811
 812 static void io_u_mark_lat_msec(struct thread_data *td, unsigned long msec)
 813 {
 814         int idx = 0;
 815
 816         switch (msec) {
 817         default:
 818                 idx = 11;
 819                 break;
 820         case 1000 ... 1999:
 821                 idx = 10;
 822                 break;
 823         case 750 ... 999:
 824                 idx = 9;
 825                 break;
 826         case 500 ... 749:
 827                 idx = 8;
 828                 break;
 829         case 250 ... 499:
 830                 idx = 7;
 831                 break;
 832         case 100 ... 249:
 833                 idx = 6;
 834                 break;
 835         case 50 ... 99:
 836                 idx = 5;
 837                 break;
 838         case 20 ... 49:
 839                 idx = 4;
 840                 break;
 841         case 10 ... 19:
 842                 idx = 3;
 843                 break;
 844         case 4 ... 9:
 845                 idx = 2;
 846                 break;
 847         case 2 ... 3:
 848                 idx = 1;
 849         case 0 ... 1:
 850                 break;
 851         }
 852
 853         assert(idx < FIO_IO_U_LAT_M_NR);
 854         td->ts.io_u_lat_m[idx]++;
 855 }
 856
 857 static void io_u_mark_latency(struct thread_data *td, unsigned long usec)
 858 {
 859         if (usec < 1000)
 860                 io_u_mark_lat_usec(td, usec);
 861         else
 862                 io_u_mark_lat_msec(td, usec / 1000);
 863 }
 864
 865 /*
 866  * Get next file to service by choosing one at random
 867  */
 868 static struct fio_file *get_next_file_rand(struct thread_data *td,
 869                                            enum fio_file_flags goodf,
 870                                            enum fio_file_flags badf)
 871 {
 872         struct fio_file *f;
 873         int fno;
 874
 875         do {
 876                 int opened = 0;
 877                 unsigned long r;
 878
 879                 if (td->o.use_os_rand) {
 880                         r = os_random_long(&td->next_file_state);
 881                         fno = (unsigned int) ((double) td->o.nr_files
 882                                 * (r / (OS_RAND_MAX + 1.0)));
 883                 } else {
 884                         r = __rand(&td->__next_file_state);
 885                         fno = (unsigned int) ((double) td->o.nr_files
 886                                 * (r / (FRAND_MAX + 1.0)));
 887                 }
 888
 889                 f = td->files[fno];
 890                 if (fio_file_done(f))
 891                         continue;
 892
 893                 if (!fio_file_open(f)) {
 894                         int err;
 895
 896                         err = td_io_open_file(td, f);
 897                         if (err)
 898                                 continue;
 899                         opened = 1;
 900                 }
 901
 902                 if ((!goodf || (f->flags & goodf)) && !(f->flags & badf)) {
 903                         dprint(FD_FILE, "get_next_file_rand: %p\n", f);
 904                         return f;
 905                 }
 906                 if (opened)
 907                         td_io_close_file(td, f);
 908         } while (1);
 909 }
 910
 911 /*
 912  * Get next file to service by doing round robin between all available ones
 913  */
 914 static struct fio_file *get_next_file_rr(struct thread_data *td, int goodf,
 915                                          int badf)
 916 {
 917         unsigned int old_next_file = td->next_file;
 918         struct fio_file *f;
 919
 920         do {
 921                 int opened = 0;
 922
 923                 f = td->files[td->next_file];
 924
 925                 td->next_file++;
 926                 if (td->next_file >= td->o.nr_files)
 927                         td->next_file = 0;
 928
 929                 dprint(FD_FILE, "trying file %s %x\n", f->file_name, f->flags);
 930                 if (fio_file_done(f)) {
 931                         f = NULL;
 932                         continue;
 933                 }
 934
 935                 if (!fio_file_open(f)) {
 936                         int err;
 937
 938                         err = td_io_open_file(td, f);
 939                         if (err) {
 940                                 dprint(FD_FILE, "error %d on open of %s\n",
 941                                         err, f->file_name);
 942                                 f = NULL;
 943                                 continue;
 944                         }
 945                         opened = 1;
 946                 }
 947
 948                 dprint(FD_FILE, "goodf=%x, badf=%x, ff=%x\n", goodf, badf,
 949                                                                 f->flags);
 950                 if ((!goodf || (f->flags & goodf)) && !(f->flags & badf))
 951                         break;
 952
 953                 if (opened)
 954                         td_io_close_file(td, f);
 955
 956                 f = NULL;
 957         } while (td->next_file != old_next_file);
 958
 959         dprint(FD_FILE, "get_next_file_rr: %p\n", f);
 960         return f;
 961 }
 962
 963 static struct fio_file *__get_next_file(struct thread_data *td)
 964 {
 965         struct fio_file *f;
 966
 967         assert(td->o.nr_files <= td->files_index);
 968
 969         if (td->nr_done_files >= td->o.nr_files) {
 970                 dprint(FD_FILE, "get_next_file: nr_open=%d, nr_done=%d,"
 971                                 " nr_files=%d\n", td->nr_open_files,
 972                                                   td->nr_done_files,
 973                                                   td->o.nr_files);
 974                 return NULL;
 975         }
 976
 977         f = td->file_service_file;
 978         if (f && fio_file_open(f) && !fio_file_closing(f)) {
 979                 if (td->o.file_service_type == FIO_FSERVICE_SEQ)
 980                         goto out;
 981                 if (td->file_service_left--)
 982                         goto out;
 983         }
 984
 985         if (td->o.file_service_type == FIO_FSERVICE_RR ||
 986             td->o.file_service_type == FIO_FSERVICE_SEQ)
 987                 f = get_next_file_rr(td, FIO_FILE_open, FIO_FILE_closing);
 988         else
 989                 f = get_next_file_rand(td, FIO_FILE_open, FIO_FILE_closing);
 990
 991         td->file_service_file = f;
 992         td->file_service_left = td->file_service_nr - 1;
 993 out:
 994         dprint(FD_FILE, "get_next_file: %p [%s]\n", f, f->file_name);
 995         return f;
 996 }
 997
 998 static struct fio_file *get_next_file(struct thread_data *td)
 999 {
1000         struct prof_io_ops *ops = &td->prof_io_ops;
1001
1002         if (ops->get_next_file)
1003                 return ops->get_next_file(td);
1004
1005         return __get_next_file(td);
1006 }
1007
1008 static int set_io_u_file(struct thread_data *td, struct io_u *io_u)
1009 {
1010         struct fio_file *f;
1011
1012         do {
1013                 f = get_next_file(td);
1014                 if (!f)
1015                         return 1;
1016
1017                 io_u->file = f;
1018                 get_file(f);
1019
1020                 if (!fill_io_u(td, io_u))
1021                         break;
1022
1023                 put_file_log(td, f);
1024                 td_io_close_file(td, f);
1025                 io_u->file = NULL;
1026                 fio_file_set_done(f);
1027                 td->nr_done_files++;
1028                 dprint(FD_FILE, "%s: is done (%d of %d)\n", f->file_name,
1029                                         td->nr_done_files, td->o.nr_files);
1030         } while (1);
1031
1032         return 0;
1033 }
1034
1035
1036 struct io_u *__get_io_u(struct thread_data *td)
1037 {
1038         struct io_u *io_u = NULL;
1039
1040         td_io_u_lock(td);
1041
1042 again:
1043         if (!flist_empty(&td->io_u_requeues))
1044                 io_u = flist_entry(td->io_u_requeues.next, struct io_u, list);
1045         else if (!queue_full(td)) {
1046                 io_u = flist_entry(td->io_u_freelist.next, struct io_u, list);
1047
1048                 io_u->buflen = 0;
1049                 io_u->resid = 0;
1050                 io_u->file = NULL;
1051                 io_u->end_io = NULL;
1052         }
1053
1054         if (io_u) {
1055                 assert(io_u->flags & IO_U_F_FREE);
1056                 io_u->flags &= ~(IO_U_F_FREE | IO_U_F_FREE_DEF);
1057                 io_u->flags &= ~(IO_U_F_TRIMMED | IO_U_F_BARRIER);
1058
1059                 io_u->error = 0;
1060                 flist_del(&io_u->list);
1061                 flist_add(&io_u->list, &td->io_u_busylist);
1062                 td->cur_depth++;
1063                 io_u->flags |= IO_U_F_IN_CUR_DEPTH;
1064         } else if (td->o.verify_async) {
1065                 /*
1066                  * We ran out, wait for async verify threads to finish and
1067                  * return one
1068                  */
1069                 pthread_cond_wait(&td->free_cond, &td->io_u_lock);
1070                 goto again;
1071         }
1072
1073         td_io_u_unlock(td);
1074         return io_u;
1075 }
1076
1077 static int check_get_trim(struct thread_data *td, struct io_u *io_u)
1078 {
1079         if (td->o.trim_backlog && td->trim_entries) {
1080                 int get_trim = 0;
1081
1082                 if (td->trim_batch) {
1083                         td->trim_batch--;
1084                         get_trim = 1;
1085                 } else if (!(td->io_hist_len % td->o.trim_backlog) &&
1086                          td->last_ddir != DDIR_READ) {
1087                         td->trim_batch = td->o.trim_batch;
1088                         if (!td->trim_batch)
1089                                 td->trim_batch = td->o.trim_backlog;
1090                         get_trim = 1;
1091                 }
1092
1093                 if (get_trim && !get_next_trim(td, io_u))
1094                         return 1;
1095         }
1096
1097         return 0;
1098 }
1099
1100 static int check_get_verify(struct thread_data *td, struct io_u *io_u)
1101 {
1102         if (td->o.verify_backlog && td->io_hist_len) {
1103                 int get_verify = 0;
1104
1105                 if (td->verify_batch) {
1106                         td->verify_batch--;
1107                         get_verify = 1;
1108                 } else if (!(td->io_hist_len % td->o.verify_backlog) &&
1109                          td->last_ddir != DDIR_READ) {
1110                         td->verify_batch = td->o.verify_batch;
1111                         if (!td->verify_batch)
1112                                 td->verify_batch = td->o.verify_backlog;
1113                         get_verify = 1;
1114                 }
1115
1116                 if (get_verify && !get_next_verify(td, io_u))
1117                         return 1;
1118         }
1119
1120         return 0;
1121 }
1122
1123 /*
1124  * Return an io_u to be processed. Gets a buflen and offset, sets direction,
1125  * etc. The returned io_u is fully ready to be prepped and submitted.
1126  */
1127 struct io_u *get_io_u(struct thread_data *td)
1128 {
1129         struct fio_file *f;
1130         struct io_u *io_u;
1131
1132         io_u = __get_io_u(td);
1133         if (!io_u) {
1134                 dprint(FD_IO, "__get_io_u failed\n");
1135                 return NULL;
1136         }
1137
1138         if (check_get_verify(td, io_u))
1139                 goto out;
1140         if (check_get_trim(td, io_u))
1141                 goto out;
1142
1143         /*
1144          * from a requeue, io_u already setup
1145          */
1146         if (io_u->file)
1147                 goto out;
1148
1149         /*
1150          * If using an iolog, grab next piece if any available.
1151          */
1152         if (td->o.read_iolog_file) {
1153                 if (read_iolog_get(td, io_u))
1154                         goto err_put;
1155         } else if (set_io_u_file(td, io_u)) {
1156                 dprint(FD_IO, "io_u %p, setting file failed\n", io_u);
1157                 goto err_put;
1158         }
1159
1160         f = io_u->file;
1161         assert(fio_file_open(f));
1162
1163         if (ddir_rw(io_u->ddir)) {
1164                 if (!io_u->buflen && !(td->io_ops->flags & FIO_NOIO)) {
1165                         dprint(FD_IO, "get_io_u: zero buflen on %p\n", io_u);
1166                         goto err_put;
1167                 }
1168
1169                 f->last_start = io_u->offset;
1170                 f->last_pos = io_u->offset + io_u->buflen;
1171
1172                 if (td->o.verify != VERIFY_NONE && io_u->ddir == DDIR_WRITE)
1173                         populate_verify_io_u(td, io_u);
1174                 else if (td->o.refill_buffers && io_u->ddir == DDIR_WRITE)
1175                         io_u_fill_buffer(td, io_u, io_u->xfer_buflen);
1176                 else if (io_u->ddir == DDIR_READ) {
1177                         /*
1178                          * Reset the buf_filled parameters so next time if the
1179                          * buffer is used for writes it is refilled.
1180                          */
1181                         io_u->buf_filled_len = 0;
1182                 }
1183         }
1184
1185         /*
1186          * Set io data pointers.
1187          */
1188         io_u->xfer_buf = io_u->buf;
1189         io_u->xfer_buflen = io_u->buflen;
1190
1191 out:
1192         assert(io_u->file);
1193         if (!td_io_prep(td, io_u)) {
1194                 if (!td->o.disable_slat)
1195                         fio_gettime(&io_u->start_time, NULL);
1196                 return io_u;
1197         }
1198 err_put:
1199         dprint(FD_IO, "get_io_u failed\n");
1200         put_io_u(td, io_u);
1201         return NULL;
1202 }
1203
1204 void io_u_log_error(struct thread_data *td, struct io_u *io_u)
1205 {
1206         const char *msg[] = { "read", "write", "sync", "datasync",
1207                                 "sync_file_range", "wait", "trim" };
1208
1209
1210
1211         log_err("fio: io_u error");
1212
1213         if (io_u->file)
1214                 log_err(" on file %s", io_u->file->file_name);
1215
1216         log_err(": %s\n", strerror(io_u->error));
1217
1218         log_err("     %s offset=%llu, buflen=%lu\n", msg[io_u->ddir],
1219                                         io_u->offset, io_u->xfer_buflen);
1220
1221         if (!td->error)
1222                 td_verror(td, io_u->error, "io_u error");
1223 }
1224
1225 static void io_completed(struct thread_data *td, struct io_u *io_u,
1226                          struct io_completion_data *icd)
1227 {
1228         /*
1229          * Older gcc's are too dumb to realize that usec is always used
1230          * initialized, silence that warning.
1231          */
1232         unsigned long uninitialized_var(usec);
1233         struct fio_file *f;
1234
1235         dprint_io_u(io_u, "io complete");
1236
1237         td_io_u_lock(td);
1238         assert(io_u->flags & IO_U_F_FLIGHT);
1239         io_u->flags &= ~(IO_U_F_FLIGHT | IO_U_F_BUSY_OK);
1240         td_io_u_unlock(td);
1241
1242         if (ddir_sync(io_u->ddir)) {
1243                 td->last_was_sync = 1;
1244                 f = io_u->file;
1245                 if (f) {
1246                         f->first_write = -1ULL;
1247                         f->last_write = -1ULL;
1248                 }
1249                 return;
1250         }
1251
1252         td->last_was_sync = 0;
1253         td->last_ddir = io_u->ddir;
1254
1255         if (!io_u->error && ddir_rw(io_u->ddir)) {
1256                 unsigned int bytes = io_u->buflen - io_u->resid;
1257                 const enum fio_ddir idx = io_u->ddir;
1258                 const enum fio_ddir odx = io_u->ddir ^ 1;
1259                 int ret;
1260
1261                 td->io_blocks[idx]++;
1262                 td->io_bytes[idx] += bytes;
1263                 td->this_io_bytes[idx] += bytes;
1264
1265                 if (idx == DDIR_WRITE) {
1266                         f = io_u->file;
1267                         if (f) {
1268                                 if (f->first_write == -1ULL ||
1269                                     io_u->offset < f->first_write)
1270                                         f->first_write = io_u->offset;
1271                                 if (f->last_write == -1ULL ||
1272                                     ((io_u->offset + bytes) > f->last_write))
1273                                         f->last_write = io_u->offset + bytes;
1274                         }
1275                 }
1276
1277                 if (ramp_time_over(td)) {
1278                         unsigned long uninitialized_var(lusec);
1279
1280                         if (!td->o.disable_clat || !td->o.disable_bw)
1281                                 lusec = utime_since(&io_u->issue_time,
1282                                                         &icd->time);
1283                         if (!td->o.disable_lat) {
1284                                 unsigned long tusec;
1285
1286                                 tusec = utime_since(&io_u->start_time,
1287                                                         &icd->time);
1288                                 add_lat_sample(td, idx, tusec, bytes);
1289                         }
1290                         if (!td->o.disable_clat) {
1291                                 add_clat_sample(td, idx, lusec, bytes);
1292                                 io_u_mark_latency(td, lusec);
1293                         }
1294                         if (!td->o.disable_bw)
1295                                 add_bw_sample(td, idx, bytes, &icd->time);
1296                         if (__should_check_rate(td, idx)) {
1297                                 td->rate_pending_usleep[idx] =
1298                                         ((td->this_io_bytes[idx] *
1299                                           td->rate_nsec_cycle[idx]) / 1000 -
1300                                          utime_since_now(&td->start));
1301                         }
1302                         if (__should_check_rate(td, idx ^ 1))
1303                                 td->rate_pending_usleep[odx] =
1304                                         ((td->this_io_bytes[odx] *
1305                                           td->rate_nsec_cycle[odx]) / 1000 -
1306                                          utime_since_now(&td->start));
1307                 }
1308
1309                 if (td_write(td) && idx == DDIR_WRITE &&
1310                     td->o.do_verify &&
1311                     td->o.verify != VERIFY_NONE)
1312                         log_io_piece(td, io_u);
1313
1314                 icd->bytes_done[idx] += bytes;
1315
1316                 if (io_u->end_io) {
1317                         ret = io_u->end_io(td, io_u);
1318                         if (ret && !icd->error)
1319                                 icd->error = ret;
1320                 }
1321         } else if (io_u->error) {
1322                 icd->error = io_u->error;
1323                 io_u_log_error(td, io_u);
1324         }
1325         if (td->o.continue_on_error && icd->error &&
1326             td_non_fatal_error(icd->error)) {
1327                 /*
1328                  * If there is a non_fatal error, then add to the error count
1329                  * and clear all the errors.
1330                  */
1331                 update_error_count(td, icd->error);
1332                 td_clear_error(td);
1333                 icd->error = 0;
1334                 io_u->error = 0;
1335         }
1336 }
1337
1338 static void init_icd(struct thread_data *td, struct io_completion_data *icd,
1339                      int nr)
1340 {
1341         if (!td->o.disable_clat || !td->o.disable_bw)
1342                 fio_gettime(&icd->time, NULL);
1343
1344         icd->nr = nr;
1345
1346         icd->error = 0;
1347         icd->bytes_done[0] = icd->bytes_done[1] = 0;
1348 }
1349
1350 static void ios_completed(struct thread_data *td,
1351                           struct io_completion_data *icd)
1352 {
1353         struct io_u *io_u;
1354         int i;
1355
1356         for (i = 0; i < icd->nr; i++) {
1357                 io_u = td->io_ops->event(td, i);
1358
1359                 io_completed(td, io_u, icd);
1360
1361                 if (!(io_u->flags & IO_U_F_FREE_DEF))
1362                         put_io_u(td, io_u);
1363         }
1364 }
1365
1366 /*
1367  * Complete a single io_u for the sync engines.
1368  */
1369 int io_u_sync_complete(struct thread_data *td, struct io_u *io_u,
1370                        unsigned long *bytes)
1371 {
1372         struct io_completion_data icd;
1373
1374         init_icd(td, &icd, 1);
1375         io_completed(td, io_u, &icd);
1376
1377         if (!(io_u->flags & IO_U_F_FREE_DEF))
1378                 put_io_u(td, io_u);
1379
1380         if (icd.error) {
1381                 td_verror(td, icd.error, "io_u_sync_complete");
1382                 return -1;
1383         }
1384
1385         if (bytes) {
1386                 bytes[0] += icd.bytes_done[0];
1387                 bytes[1] += icd.bytes_done[1];
1388         }
1389
1390         return 0;
1391 }
1392
1393 /*
1394  * Called to complete min_events number of io for the async engines.
1395  */
1396 int io_u_queued_complete(struct thread_data *td, int min_evts,
1397                          unsigned long *bytes)
1398 {
1399         struct io_completion_data icd;
1400         struct timespec *tvp = NULL;
1401         int ret;
1402         struct timespec ts = { .tv_sec = 0, .tv_nsec = 0, };
1403
1404         dprint(FD_IO, "io_u_queued_completed: min=%d\n", min_evts);
1405
1406         if (!min_evts)
1407                 tvp = &ts;
1408
1409         ret = td_io_getevents(td, min_evts, td->o.iodepth_batch_complete, tvp);
1410         if (ret < 0) {
1411                 td_verror(td, -ret, "td_io_getevents");
1412                 return ret;
1413         } else if (!ret)
1414                 return ret;
1415
1416         init_icd(td, &icd, ret);
1417         ios_completed(td, &icd);
1418         if (icd.error) {
1419                 td_verror(td, icd.error, "io_u_queued_complete");
1420                 return -1;
1421         }
1422
1423         if (bytes) {
1424                 bytes[0] += icd.bytes_done[0];
1425                 bytes[1] += icd.bytes_done[1];
1426         }
1427
1428         return 0;
1429 }
1430
1431 /*
1432  * Call when io_u is really queued, to update the submission latency.
1433  */
1434 void io_u_queued(struct thread_data *td, struct io_u *io_u)
1435 {
1436         if (!td->o.disable_slat) {
1437                 unsigned long slat_time;
1438
1439                 slat_time = utime_since(&io_u->start_time, &io_u->issue_time);
1440                 add_slat_sample(td, io_u->ddir, slat_time, io_u->xfer_buflen);
1441         }
1442 }
1443
1444 /*
1445  * "randomly" fill the buffer contents
1446  */
1447 void io_u_fill_buffer(struct thread_data *td, struct io_u *io_u,
1448                       unsigned int max_bs)
1449 {
1450         io_u->buf_filled_len = 0;
1451
1452         if (!td->o.zero_buffers)
1453                 fill_random_buf(io_u->buf, max_bs);
1454         else
1455                 memset(io_u->buf, 0, max_bs);
1456 }