verify.c

   1 /*
   2  * IO verification helpers
   3  */
   4 #include <unistd.h>
   5 #include <fcntl.h>
   6 #include <string.h>
   7 #include <assert.h>
   8
   9 #include "fio.h"
  10
  11 #include "crc/md5.h"
  12 #include "crc/crc64.h"
  13 #include "crc/crc32.h"
  14 #include "crc/crc32c.h"
  15 #include "crc/crc16.h"
  16 #include "crc/crc7.h"
  17 #include "crc/sha256.h"
  18 #include "crc/sha512.h"
  19
  20 static void fill_random_bytes(struct thread_data *td, void *p, unsigned int len)
  21 {
  22         unsigned int todo;
  23         int r;
  24
  25         while (len) {
  26                 r = os_random_long(&td->verify_state);
  27
  28                 /*
  29                  * lrand48_r seems to be broken and only fill the bottom
  30                  * 32-bits, even on 64-bit archs with 64-bit longs
  31                  */
  32                 todo = sizeof(r);
  33                 if (todo > len)
  34                         todo = len;
  35
  36                 memcpy(p, &r, todo);
  37
  38                 len -= todo;
  39                 p += todo;
  40         }
  41 }
  42
  43 static void fill_pattern(struct thread_data *td, void *p, unsigned int len)
  44 {
  45         switch (td->o.verify_pattern_bytes) {
  46         case 0:
  47                 dprint(FD_VERIFY, "fill random bytes len=%u\n", len);
  48                 fill_random_bytes(td, p, len);
  49                 break;
  50         case 1:
  51                 dprint(FD_VERIFY, "fill verify pattern b=0 len=%u\n", len);
  52                 memset(p, td->o.verify_pattern, len);
  53                 break;
  54         case 2:
  55         case 3:
  56         case 4: {
  57                 unsigned int pattern = td->o.verify_pattern;
  58                 unsigned int i = 0;
  59                 unsigned char c1, c2, c3, c4;
  60                 unsigned char *b = p;
  61
  62                 dprint(FD_VERIFY, "fill verify pattern b=%d len=%u\n",
  63                                         td->o.verify_pattern_bytes, len);
  64
  65                 c1 = pattern & 0xff;
  66                 pattern >>= 8;
  67                 c2 = pattern & 0xff;
  68                 pattern >>= 8;
  69                 c3 = pattern & 0xff;
  70                 pattern >>= 8;
  71                 c4 = pattern & 0xff;
  72
  73                 while (i < len) {
  74                         b[i++] = c1;
  75                         if (i == len)
  76                                 break;
  77                         b[i++] = c2;
  78                         if (td->o.verify_pattern_bytes == 2 || i == len)
  79                                 continue;
  80                         b[i++] = c3;
  81                         if (td->o.verify_pattern_bytes == 3 || i == len)
  82                                 continue;
  83                         b[i++] = c4;
  84                 }
  85                 break;
  86                 }
  87         }
  88 }
  89
  90 static void memswp(void *buf1, void *buf2, unsigned int len)
  91 {
  92         char swap[200];
  93
  94         assert(len <= sizeof(swap));
  95
  96         memcpy(&swap, buf1, len);
  97         memcpy(buf1, buf2, len);
  98         memcpy(buf2, &swap, len);
  99 }
 100
 101 static void hexdump(void *buffer, int len)
 102 {
 103         unsigned char *p = buffer;
 104         int i;
 105
 106         for (i = 0; i < len; i++)
 107                 log_info("%02x", p[i]);
 108         log_info("\n");
 109 }
 110
 111 /*
 112  * Prepare for seperation of verify_header and checksum header
 113  */
 114 static inline unsigned int __hdr_size(int verify_type)
 115 {
 116         unsigned int len = len;
 117
 118         switch (verify_type) {
 119         case VERIFY_NONE:
 120         case VERIFY_NULL:
 121                 len = 0;
 122                 break;
 123         case VERIFY_MD5:
 124                 len = sizeof(struct vhdr_md5);
 125                 break;
 126         case VERIFY_CRC64:
 127                 len = sizeof(struct vhdr_crc64);
 128                 break;
 129         case VERIFY_CRC32C:
 130         case VERIFY_CRC32:
 131                 len = sizeof(struct vhdr_crc32);
 132                 break;
 133         case VERIFY_CRC16:
 134                 len = sizeof(struct vhdr_crc16);
 135                 break;
 136         case VERIFY_CRC7:
 137                 len = sizeof(struct vhdr_crc7);
 138                 break;
 139         case VERIFY_SHA256:
 140                 len = sizeof(struct vhdr_sha256);
 141                 break;
 142         case VERIFY_SHA512:
 143                 len = sizeof(struct vhdr_sha512);
 144                 break;
 145         case VERIFY_META:
 146                 len = sizeof(struct vhdr_meta);
 147                 break;
 148         default:
 149                 log_err("fio: unknown verify header!\n");
 150                 assert(0);
 151         }
 152
 153         return len + sizeof(struct verify_header);
 154 }
 155
 156 static inline unsigned int hdr_size(struct verify_header *hdr)
 157 {
 158         return __hdr_size(hdr->verify_type);
 159 }
 160
 161 static void *hdr_priv(struct verify_header *hdr)
 162 {
 163         void *priv = hdr;
 164
 165         return priv + sizeof(struct verify_header);
 166 }
 167
 168 /*
 169  * Return data area 'header_num'
 170  */
 171 static inline void *io_u_verify_off(struct verify_header *hdr,
 172                                     struct io_u *io_u, unsigned char header_num)
 173 {
 174         return io_u->buf + header_num * hdr->len + hdr_size(hdr);
 175 }
 176
 177 static int verify_io_u_meta(struct verify_header *hdr, struct thread_data *td,
 178                             struct io_u *io_u, unsigned int header_num)
 179 {
 180         struct vhdr_meta *vh = hdr_priv(hdr);
 181
 182         dprint(FD_VERIFY, "meta verify io_u %p, len %u\n", io_u, hdr->len);
 183
 184         if (vh->offset != io_u->offset + header_num * td->o.verify_interval) {
 185                 log_err("meta: verify failed at %llu/%u\n",
 186                                 io_u->offset + header_num * hdr->len, hdr->len);
 187                 return EIO;
 188         }
 189
 190         return 0;
 191 }
 192
 193 static int verify_io_u_sha512(struct verify_header *hdr, struct io_u *io_u,
 194                               unsigned int header_num)
 195 {
 196         void *p = io_u_verify_off(hdr, io_u, header_num);
 197         struct vhdr_sha512 *vh = hdr_priv(hdr);
 198         uint8_t sha512[128];
 199         struct sha512_ctx sha512_ctx = {
 200                 .buf = sha512,
 201         };
 202
 203         dprint(FD_VERIFY, "sha512 verify io_u %p, len %u\n", io_u, hdr->len);
 204
 205         sha512_init(&sha512_ctx);
 206         sha512_update(&sha512_ctx, p, hdr->len - hdr_size(hdr));
 207
 208         if (memcmp(vh->sha512, sha512_ctx.buf, sizeof(sha512))) {
 209                 log_err("sha512: verify failed at %llu/%u\n",
 210                                 io_u->offset + header_num * hdr->len, hdr->len);
 211                 hexdump(vh->sha512, sizeof(vh->sha512));
 212                 hexdump(sha512_ctx.buf, sizeof(sha512));
 213                 return EIO;
 214         }
 215
 216         return 0;
 217 }
 218
 219 static int verify_io_u_sha256(struct verify_header *hdr, struct io_u *io_u,
 220                               unsigned int header_num)
 221 {
 222         void *p = io_u_verify_off(hdr, io_u, header_num);
 223         struct vhdr_sha256 *vh = hdr_priv(hdr);
 224         uint8_t sha256[128];
 225         struct sha256_ctx sha256_ctx = {
 226                 .buf = sha256,
 227         };
 228
 229         dprint(FD_VERIFY, "sha256 verify io_u %p, len %u\n", io_u, hdr->len);
 230
 231         sha256_init(&sha256_ctx);
 232         sha256_update(&sha256_ctx, p, hdr->len - hdr_size(hdr));
 233
 234         if (memcmp(vh->sha256, sha256_ctx.buf, sizeof(sha256))) {
 235                 log_err("sha256: verify failed at %llu/%u\n",
 236                                 io_u->offset + header_num * hdr->len, hdr->len);
 237                 hexdump(vh->sha256, sizeof(vh->sha256));
 238                 hexdump(sha256_ctx.buf, sizeof(sha256));
 239                 return EIO;
 240         }
 241
 242         return 0;
 243 }
 244
 245 static int verify_io_u_crc7(struct verify_header *hdr, struct io_u *io_u,
 246                             unsigned char header_num)
 247 {
 248         void *p = io_u_verify_off(hdr, io_u, header_num);
 249         struct vhdr_crc7 *vh = hdr_priv(hdr);
 250         unsigned char c;
 251
 252         dprint(FD_VERIFY, "crc7 verify io_u %p, len %u\n", io_u, hdr->len);
 253
 254         c = crc7(p, hdr->len - hdr_size(hdr));
 255
 256         if (c != vh->crc7) {
 257                 log_err("crc7: verify failed at %llu/%u\n",
 258                                 io_u->offset + header_num * hdr->len, hdr->len);
 259                 log_err("crc7: wanted %x, got %x\n", vh->crc7, c);
 260                 return EIO;
 261         }
 262
 263         return 0;
 264 }
 265
 266 static int verify_io_u_crc16(struct verify_header *hdr, struct io_u *io_u,
 267                              unsigned int header_num)
 268 {
 269         void *p = io_u_verify_off(hdr, io_u, header_num);
 270         struct vhdr_crc16 *vh = hdr_priv(hdr);
 271         unsigned short c;
 272
 273         dprint(FD_VERIFY, "crc16 verify io_u %p, len %u\n", io_u, hdr->len);
 274
 275         c = crc16(p, hdr->len - hdr_size(hdr));
 276
 277         if (c != vh->crc16) {
 278                 log_err("crc16: verify failed at %llu/%u\n",
 279                                 io_u->offset + header_num * hdr->len, hdr->len);
 280                 log_err("crc16: wanted %x, got %x\n", vh->crc16, c);
 281                 return EIO;
 282         }
 283
 284         return 0;
 285 }
 286
 287 static int verify_io_u_crc64(struct verify_header *hdr, struct io_u *io_u,
 288                              unsigned int header_num)
 289 {
 290         void *p = io_u_verify_off(hdr, io_u, header_num);
 291         struct vhdr_crc64 *vh = hdr_priv(hdr);
 292         unsigned long long c;
 293
 294         dprint(FD_VERIFY, "crc64 verify io_u %p, len %u\n", io_u, hdr->len);
 295
 296         c = crc64(p, hdr->len - hdr_size(hdr));
 297
 298         if (c != vh->crc64) {
 299                 log_err("crc64: verify failed at %llu/%u\n",
 300                                 io_u->offset + header_num * hdr->len,
 301                                 hdr->len);
 302                 log_err("crc64: wanted %llx, got %llx\n",
 303                                         (unsigned long long) vh->crc64, c);
 304                 return EIO;
 305         }
 306
 307         return 0;
 308 }
 309
 310 static int verify_io_u_crc32(struct verify_header *hdr, struct io_u *io_u,
 311                              unsigned int header_num)
 312 {
 313         void *p = io_u_verify_off(hdr, io_u, header_num);
 314         struct vhdr_crc32 *vh = hdr_priv(hdr);
 315         uint32_t c;
 316
 317         dprint(FD_VERIFY, "crc32 verify io_u %p, len %u\n", io_u, hdr->len);
 318
 319         c = crc32(p, hdr->len - hdr_size(hdr));
 320
 321         if (c != vh->crc32) {
 322                 log_err("crc32: verify failed at %llu/%u\n",
 323                                 io_u->offset + header_num * hdr->len, hdr->len);
 324                 log_err("crc32: wanted %x, got %x\n", vh->crc32, c);
 325                 return EIO;
 326         }
 327
 328         return 0;
 329 }
 330
 331 static int verify_io_u_crc32c(struct verify_header *hdr, struct io_u *io_u,
 332                               unsigned int header_num)
 333 {
 334         void *p = io_u_verify_off(hdr, io_u, header_num);
 335         struct vhdr_crc32 *vh = hdr_priv(hdr);
 336         uint32_t c;
 337
 338         dprint(FD_VERIFY, "crc32c verify io_u %p, len %u\n", io_u, hdr->len);
 339
 340         c = crc32c(p, hdr->len - hdr_size(hdr));
 341
 342         if (c != vh->crc32) {
 343                 log_err("crc32c: verify failed at %llu/%u\n",
 344                                 io_u->offset + header_num * hdr->len, hdr->len);
 345                 log_err("crc32c: wanted %x, got %x\n", vh->crc32, c);
 346                 return EIO;
 347         }
 348
 349         return 0;
 350 }
 351
 352 static int verify_io_u_md5(struct verify_header *hdr, struct io_u *io_u,
 353                            unsigned int header_num)
 354 {
 355         void *p = io_u_verify_off(hdr, io_u, header_num);
 356         struct vhdr_md5 *vh = hdr_priv(hdr);
 357         uint32_t hash[MD5_HASH_WORDS];
 358         struct md5_ctx md5_ctx = {
 359                 .hash = hash,
 360         };
 361
 362         dprint(FD_VERIFY, "md5 verify io_u %p, len %u\n", io_u, hdr->len);
 363
 364         md5_init(&md5_ctx);
 365         md5_update(&md5_ctx, p, hdr->len - hdr_size(hdr));
 366
 367         if (memcmp(vh->md5_digest, md5_ctx.hash, sizeof(hash))) {
 368                 log_err("md5: verify failed at %llu/%u\n",
 369                                 io_u->offset + header_num * hdr->len, hdr->len);
 370                 hexdump(vh->md5_digest, sizeof(vh->md5_digest));
 371                 hexdump(md5_ctx.hash, sizeof(hash));
 372                 return EIO;
 373         }
 374
 375         return 0;
 376 }
 377
 378 static unsigned int hweight8(unsigned int w)
 379 {
 380         unsigned int res = w - ((w >> 1) & 0x55);
 381
 382         res = (res & 0x33) + ((res >> 2) & 0x33);
 383         return (res + (res >> 4)) & 0x0F;
 384 }
 385
 386 int verify_io_u_pattern(unsigned long pattern, unsigned long pattern_size,
 387                         char *buf, unsigned int len, unsigned int mod)
 388 {
 389         unsigned int i;
 390         char split_pattern[4];
 391
 392         for (i = 0; i < 4; i++) {
 393                 split_pattern[i] = pattern & 0xff;
 394                 pattern >>= 8;
 395         }
 396
 397         for (i = 0; i < len; i++) {
 398                 if (buf[i] != split_pattern[mod]) {
 399                         unsigned int bits;
 400
 401                         bits = hweight8(buf[i] ^ split_pattern[mod]);
 402                         log_err("fio: got pattern %x, wanted %x. Bad bits %d\n",
 403                                 buf[i], split_pattern[mod], bits);
 404                         log_err("fio: bad pattern block offset %u\n", i);
 405                         return EIO;
 406                 }
 407                 mod++;
 408                 if (mod == pattern_size)
 409                         mod = 0;
 410         }
 411
 412         return 0;
 413 }
 414
 415 int verify_io_u(struct thread_data *td, struct io_u *io_u)
 416 {
 417         struct verify_header *hdr;
 418         unsigned int hdr_size, hdr_inc, hdr_num = 0;
 419         void *p;
 420         int ret;
 421
 422         if (td->o.verify == VERIFY_NULL || io_u->ddir != DDIR_READ)
 423                 return 0;
 424
 425         hdr_inc = io_u->buflen;
 426         if (td->o.verify_interval)
 427                 hdr_inc = td->o.verify_interval;
 428
 429         ret = 0;
 430         for (p = io_u->buf; p < io_u->buf + io_u->buflen;
 431              p += hdr_inc, hdr_num++) {
 432                 if (ret && td->o.verify_fatal) {
 433                         td->terminate = 1;
 434                         break;
 435                 }
 436                 hdr_size = __hdr_size(td->o.verify);
 437                 if (td->o.verify_offset)
 438                         memswp(p, p + td->o.verify_offset, hdr_size);
 439                 hdr = p;
 440
 441                 if (hdr->fio_magic != FIO_HDR_MAGIC) {
 442                         log_err("Bad verify header %x\n", hdr->fio_magic);
 443                         return EIO;
 444                 }
 445
 446                 if (td->o.verify_pattern_bytes) {
 447                         dprint(FD_VERIFY, "pattern verify io_u %p, len %u\n",
 448                                                                 io_u, hdr->len);
 449                         ret = verify_io_u_pattern(td->o.verify_pattern,
 450                                                   td->o.verify_pattern_bytes,
 451                                                   p + hdr_size,
 452                                                   hdr_inc - hdr_size,
 453                                                   hdr_size % 4);
 454                         if (ret)
 455                                 log_err("fio: verify failed at %llu/%u\n",
 456                                         io_u->offset + hdr_num * hdr->len,
 457                                         hdr->len);
 458                         continue;
 459                 }
 460
 461                 switch (hdr->verify_type) {
 462                 case VERIFY_MD5:
 463                         ret = verify_io_u_md5(hdr, io_u, hdr_num);
 464                         break;
 465                 case VERIFY_CRC64:
 466                         ret = verify_io_u_crc64(hdr, io_u, hdr_num);
 467                         break;
 468                 case VERIFY_CRC32C:
 469                         ret = verify_io_u_crc32c(hdr, io_u, hdr_num);
 470                         break;
 471                 case VERIFY_CRC32:
 472                         ret = verify_io_u_crc32(hdr, io_u, hdr_num);
 473                         break;
 474                 case VERIFY_CRC16:
 475                         ret = verify_io_u_crc16(hdr, io_u, hdr_num);
 476                         break;
 477                 case VERIFY_CRC7:
 478                         ret = verify_io_u_crc7(hdr, io_u, hdr_num);
 479                         break;
 480                 case VERIFY_SHA256:
 481                         ret = verify_io_u_sha256(hdr, io_u, hdr_num);
 482                         break;
 483                 case VERIFY_SHA512:
 484                         ret = verify_io_u_sha512(hdr, io_u, hdr_num);
 485                         break;
 486                 case VERIFY_META:
 487                         ret = verify_io_u_meta(hdr, td, io_u, hdr_num);
 488                         break;
 489                 default:
 490                         log_err("Bad verify type %u\n", hdr->verify_type);
 491                         ret = EINVAL;
 492                 }
 493         }
 494
 495         return ret;
 496 }
 497
 498 static void fill_meta(struct verify_header *hdr, struct thread_data *td,
 499                       struct io_u *io_u, unsigned int header_num)
 500 {
 501         struct vhdr_meta *vh = hdr_priv(hdr);
 502
 503         vh->thread = td->thread_number;
 504
 505         vh->time_sec = io_u->start_time.tv_sec;
 506         vh->time_usec = io_u->start_time.tv_usec;
 507
 508         vh->numberio = td->io_issues[DDIR_WRITE];
 509
 510         vh->offset = io_u->offset + header_num * td->o.verify_interval;
 511 }
 512
 513 static void fill_sha512(struct verify_header *hdr, void *p, unsigned int len)
 514 {
 515         struct vhdr_sha512 *vh = hdr_priv(hdr);
 516         struct sha512_ctx sha512_ctx = {
 517                 .buf = vh->sha512,
 518         };
 519
 520         sha512_init(&sha512_ctx);
 521         sha512_update(&sha512_ctx, p, len);
 522 }
 523
 524 static void fill_sha256(struct verify_header *hdr, void *p, unsigned int len)
 525 {
 526         struct vhdr_sha256 *vh = hdr_priv(hdr);
 527         struct sha256_ctx sha256_ctx = {
 528                 .buf = vh->sha256,
 529         };
 530
 531         sha256_init(&sha256_ctx);
 532         sha256_update(&sha256_ctx, p, len);
 533 }
 534
 535 static void fill_crc7(struct verify_header *hdr, void *p, unsigned int len)
 536 {
 537         struct vhdr_crc7 *vh = hdr_priv(hdr);
 538
 539         vh->crc7 = crc7(p, len);
 540 }
 541
 542 static void fill_crc16(struct verify_header *hdr, void *p, unsigned int len)
 543 {
 544         struct vhdr_crc16 *vh = hdr_priv(hdr);
 545
 546         vh->crc16 = crc16(p, len);
 547 }
 548
 549 static void fill_crc32(struct verify_header *hdr, void *p, unsigned int len)
 550 {
 551         struct vhdr_crc32 *vh = hdr_priv(hdr);
 552
 553         vh->crc32 = crc32(p, len);
 554 }
 555
 556 static void fill_crc32c(struct verify_header *hdr, void *p, unsigned int len)
 557 {
 558         struct vhdr_crc32 *vh = hdr_priv(hdr);
 559
 560         vh->crc32 = crc32c(p, len);
 561 }
 562
 563 static void fill_crc64(struct verify_header *hdr, void *p, unsigned int len)
 564 {
 565         struct vhdr_crc64 *vh = hdr_priv(hdr);
 566
 567         vh->crc64 = crc64(p, len);
 568 }
 569
 570 static void fill_md5(struct verify_header *hdr, void *p, unsigned int len)
 571 {
 572         struct vhdr_md5 *vh = hdr_priv(hdr);
 573         struct md5_ctx md5_ctx = {
 574                 .hash = (uint32_t *) vh->md5_digest,
 575         };
 576
 577         md5_init(&md5_ctx);
 578         md5_update(&md5_ctx, p, len);
 579 }
 580
 581 /*
 582  * fill body of io_u->buf with random data and add a header with the
 583  * crc32 or md5 sum of that data.
 584  */
 585 void populate_verify_io_u(struct thread_data *td, struct io_u *io_u)
 586 {
 587         struct verify_header *hdr;
 588         void *p = io_u->buf, *data;
 589         unsigned int hdr_inc, data_len, header_num = 0;
 590
 591         if (td->o.verify == VERIFY_NULL)
 592                 return;
 593
 594         fill_pattern(td, p, io_u->buflen);
 595
 596         hdr_inc = io_u->buflen;
 597         if (td->o.verify_interval)
 598                 hdr_inc = td->o.verify_interval;
 599
 600         for (; p < io_u->buf + io_u->buflen; p += hdr_inc) {
 601                 hdr = p;
 602
 603                 hdr->fio_magic = FIO_HDR_MAGIC;
 604                 hdr->verify_type = td->o.verify;
 605                 hdr->len = hdr_inc;
 606                 data_len = hdr_inc - hdr_size(hdr);
 607
 608                 data = p + hdr_size(hdr);
 609                 switch (td->o.verify) {
 610                 case VERIFY_MD5:
 611                         dprint(FD_VERIFY, "fill md5 io_u %p, len %u\n",
 612                                                         io_u, hdr->len);
 613                         fill_md5(hdr, data, data_len);
 614                         break;
 615                 case VERIFY_CRC64:
 616                         dprint(FD_VERIFY, "fill crc64 io_u %p, len %u\n",
 617                                                         io_u, hdr->len);
 618                         fill_crc64(hdr, data, data_len);
 619                         break;
 620                 case VERIFY_CRC32C:
 621                         dprint(FD_VERIFY, "fill crc32c io_u %p, len %u\n",
 622                                                         io_u, hdr->len);
 623                         fill_crc32c(hdr, data, data_len);
 624                         break;
 625                 case VERIFY_CRC32:
 626                         dprint(FD_VERIFY, "fill crc32 io_u %p, len %u\n",
 627                                                         io_u, hdr->len);
 628                         fill_crc32(hdr, data, data_len);
 629                         break;
 630                 case VERIFY_CRC16:
 631                         dprint(FD_VERIFY, "fill crc16 io_u %p, len %u\n",
 632                                                         io_u, hdr->len);
 633                         fill_crc16(hdr, data, data_len);
 634                         break;
 635                 case VERIFY_CRC7:
 636                         dprint(FD_VERIFY, "fill crc7 io_u %p, len %u\n",
 637                                                         io_u, hdr->len);
 638                         fill_crc7(hdr, data, data_len);
 639                         break;
 640                 case VERIFY_SHA256:
 641                         dprint(FD_VERIFY, "fill sha256 io_u %p, len %u\n",
 642                                                         io_u, hdr->len);
 643                         fill_sha256(hdr, data, data_len);
 644                         break;
 645                 case VERIFY_SHA512:
 646                         dprint(FD_VERIFY, "fill sha512 io_u %p, len %u\n",
 647                                                         io_u, hdr->len);
 648                         fill_sha512(hdr, data, data_len);
 649                         break;
 650                 case VERIFY_META:
 651                         dprint(FD_VERIFY, "fill meta io_u %p, len %u\n",
 652                                                         io_u, hdr->len);
 653                         fill_meta(hdr, td, io_u, header_num);
 654                         break;
 655                 default:
 656                         log_err("fio: bad verify type: %d\n", td->o.verify);
 657                         assert(0);
 658                 }
 659                 if (td->o.verify_offset)
 660                         memswp(p, p + td->o.verify_offset, hdr_size(hdr));
 661                 header_num++;
 662         }
 663 }
 664
 665 int get_next_verify(struct thread_data *td, struct io_u *io_u)
 666 {
 667         struct io_piece *ipo = NULL;
 668
 669         /*
 670          * this io_u is from a requeue, we already filled the offsets
 671          */
 672         if (io_u->file)
 673                 return 0;
 674
 675         if (!RB_EMPTY_ROOT(&td->io_hist_tree)) {
 676                 struct rb_node *n = rb_first(&td->io_hist_tree);
 677
 678                 ipo = rb_entry(n, struct io_piece, rb_node);
 679                 rb_erase(n, &td->io_hist_tree);
 680         } else if (!flist_empty(&td->io_hist_list)) {
 681                 ipo = flist_entry(td->io_hist_list.next, struct io_piece, list);
 682                 flist_del(&ipo->list);
 683         }
 684
 685         if (ipo) {
 686                 io_u->offset = ipo->offset;
 687                 io_u->buflen = ipo->len;
 688                 io_u->file = ipo->file;
 689
 690                 if ((io_u->file->flags & FIO_FILE_OPEN) == 0) {
 691                         int r = td_io_open_file(td, io_u->file);
 692
 693                         if (r) {
 694                                 dprint(FD_VERIFY, "failed file %s open\n",
 695                                                 io_u->file->file_name);
 696                                 return 1;
 697                         }
 698                 }
 699
 700                 get_file(ipo->file);
 701                 assert(io_u->file->flags & FIO_FILE_OPEN);
 702                 io_u->ddir = DDIR_READ;
 703                 io_u->xfer_buf = io_u->buf;
 704                 io_u->xfer_buflen = io_u->buflen;
 705                 free(ipo);
 706                 dprint(FD_VERIFY, "get_next_verify: ret io_u %p\n", io_u);
 707                 return 0;
 708         }
 709
 710         dprint(FD_VERIFY, "get_next_verify: empty\n");
 711         return 1;
 712 }