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