genfio: Splitting gen_template in 2 parts
[fio.git] / 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 #include <pthread.h>
9 #include <libgen.h>
10
11 #include "fio.h"
12 #include "verify.h"
13 #include "trim.h"
14 #include "lib/rand.h"
15 #include "lib/hweight.h"
16
17 #include "crc/md5.h"
18 #include "crc/crc64.h"
19 #include "crc/crc32.h"
20 #include "crc/crc32c.h"
21 #include "crc/crc16.h"
22 #include "crc/crc7.h"
23 #include "crc/sha256.h"
24 #include "crc/sha512.h"
25 #include "crc/sha1.h"
26
27 static void populate_hdr(struct thread_data *td, struct io_u *io_u,
28                          struct verify_header *hdr, unsigned int header_num,
29                          unsigned int header_len);
30
31 void fill_pattern(struct thread_data *td, void *p, unsigned int len, struct io_u *io_u, unsigned long seed, int use_seed)
32 {
33         switch (td->o.verify_pattern_bytes) {
34         case 0:
35                 dprint(FD_VERIFY, "fill random bytes len=%u\n", len);
36                 if (use_seed)
37                         __fill_random_buf(p, len, seed);
38                 else
39                         io_u->rand_seed = fill_random_buf(&td->buf_state, p, len);
40                 break;
41         case 1:
42                 if (io_u->buf_filled_len >= len) {
43                         dprint(FD_VERIFY, "using already filled verify pattern b=0 len=%u\n", len);
44                         return;
45                 }
46                 dprint(FD_VERIFY, "fill verify pattern b=0 len=%u\n", len);
47                 memset(p, td->o.verify_pattern[0], len);
48                 io_u->buf_filled_len = len;
49                 break;
50         default: {
51                 unsigned int i = 0, size = 0;
52                 unsigned char *b = p;
53
54                 if (io_u->buf_filled_len >= len) {
55                         dprint(FD_VERIFY, "using already filled verify pattern b=%d len=%u\n",
56                                         td->o.verify_pattern_bytes, len);
57                         return;
58                 }
59
60                 dprint(FD_VERIFY, "fill verify pattern b=%d len=%u\n",
61                                         td->o.verify_pattern_bytes, len);
62
63                 while (i < len) {
64                         size = td->o.verify_pattern_bytes;
65                         if (size > (len - i))
66                                 size = len - i;
67                         memcpy(b+i, td->o.verify_pattern, size);
68                         i += size;
69                 }
70                 io_u->buf_filled_len = len;
71                 break;
72                 }
73         }
74 }
75
76 static unsigned int get_hdr_inc(struct thread_data *td, struct io_u *io_u)
77 {
78         unsigned int hdr_inc;
79
80         hdr_inc = io_u->buflen;
81         if (td->o.verify_interval && td->o.verify_interval <= io_u->buflen)
82                 hdr_inc = td->o.verify_interval;
83
84         return hdr_inc;
85 }
86
87 static void fill_pattern_headers(struct thread_data *td, struct io_u *io_u,
88                                  unsigned long seed, int use_seed)
89 {
90         unsigned int hdr_inc, header_num;
91         struct verify_header *hdr;
92         void *p = io_u->buf;
93
94         fill_pattern(td, p, io_u->buflen, io_u, seed, use_seed);
95
96         hdr_inc = get_hdr_inc(td, io_u);
97         header_num = 0;
98         for (; p < io_u->buf + io_u->buflen; p += hdr_inc) {
99                 hdr = p;
100                 populate_hdr(td, io_u, hdr, header_num, hdr_inc);
101                 header_num++;
102         }
103 }
104
105 static void memswp(void *buf1, void *buf2, unsigned int len)
106 {
107         char swap[200];
108
109         assert(len <= sizeof(swap));
110
111         memcpy(&swap, buf1, len);
112         memcpy(buf1, buf2, len);
113         memcpy(buf2, &swap, len);
114 }
115
116 static void hexdump(void *buffer, int len)
117 {
118         unsigned char *p = buffer;
119         int i;
120
121         for (i = 0; i < len; i++)
122                 log_err("%02x", p[i]);
123         log_err("\n");
124 }
125
126 /*
127  * Prepare for seperation of verify_header and checksum header
128  */
129 static inline unsigned int __hdr_size(int verify_type)
130 {
131         unsigned int len = 0;
132
133         switch (verify_type) {
134         case VERIFY_NONE:
135         case VERIFY_NULL:
136                 len = 0;
137                 break;
138         case VERIFY_MD5:
139                 len = sizeof(struct vhdr_md5);
140                 break;
141         case VERIFY_CRC64:
142                 len = sizeof(struct vhdr_crc64);
143                 break;
144         case VERIFY_CRC32C:
145         case VERIFY_CRC32:
146         case VERIFY_CRC32C_INTEL:
147                 len = sizeof(struct vhdr_crc32);
148                 break;
149         case VERIFY_CRC16:
150                 len = sizeof(struct vhdr_crc16);
151                 break;
152         case VERIFY_CRC7:
153                 len = sizeof(struct vhdr_crc7);
154                 break;
155         case VERIFY_SHA256:
156                 len = sizeof(struct vhdr_sha256);
157                 break;
158         case VERIFY_SHA512:
159                 len = sizeof(struct vhdr_sha512);
160                 break;
161         case VERIFY_META:
162                 len = sizeof(struct vhdr_meta);
163                 break;
164         case VERIFY_SHA1:
165                 len = sizeof(struct vhdr_sha1);
166                 break;
167         case VERIFY_PATTERN:
168                 len = 0;
169                 break;
170         default:
171                 log_err("fio: unknown verify header!\n");
172                 assert(0);
173         }
174
175         return len + sizeof(struct verify_header);
176 }
177
178 static inline unsigned int hdr_size(struct verify_header *hdr)
179 {
180         return __hdr_size(hdr->verify_type);
181 }
182
183 static void *hdr_priv(struct verify_header *hdr)
184 {
185         void *priv = hdr;
186
187         return priv + sizeof(struct verify_header);
188 }
189
190 /*
191  * Verify container, pass info to verify handlers and allow them to
192  * pass info back in case of error
193  */
194 struct vcont {
195         /*
196          * Input
197          */
198         struct io_u *io_u;
199         unsigned int hdr_num;
200         struct thread_data *td;
201
202         /*
203          * Output, only valid in case of error
204          */
205         const char *name;
206         void *good_crc;
207         void *bad_crc;
208         unsigned int crc_len;
209 };
210
211 static void dump_buf(char *buf, unsigned int len, unsigned long long offset,
212                      const char *type, struct fio_file *f)
213 {
214         char *ptr, fname[256];
215         int ret, fd;
216
217         ptr = strdup(f->file_name);
218         strcpy(fname, basename(ptr));
219
220         sprintf(fname + strlen(fname), ".%llu.%s", offset, type);
221
222         fd = open(fname, O_CREAT | O_TRUNC | O_WRONLY, 0644);
223         if (fd < 0) {
224                 perror("open verify buf file");
225                 return;
226         }
227
228         while (len) {
229                 ret = write(fd, buf, len);
230                 if (!ret)
231                         break;
232                 else if (ret < 0) {
233                         perror("write verify buf file");
234                         break;
235                 }
236                 len -= ret;
237                 buf += ret;
238         }
239
240         close(fd);
241         log_err("       %s data dumped as %s\n", type, fname);
242         free(ptr);
243 }
244
245 /*
246  * Dump the contents of the read block and re-generate the correct data
247  * and dump that too.
248  */
249 static void dump_verify_buffers(struct verify_header *hdr, struct vcont *vc)
250 {
251         struct thread_data *td = vc->td;
252         struct io_u *io_u = vc->io_u;
253         unsigned long hdr_offset;
254         struct io_u dummy;
255         void *buf;
256
257         if (!td->o.verify_dump)
258                 return;
259
260         /*
261          * Dump the contents we just read off disk
262          */
263         hdr_offset = vc->hdr_num * hdr->len;
264
265         dump_buf(io_u->buf + hdr_offset, hdr->len, io_u->offset + hdr_offset,
266                         "received", vc->io_u->file);
267
268         /*
269          * Allocate a new buf and re-generate the original data
270          */
271         buf = malloc(io_u->buflen);
272         dummy = *io_u;
273         dummy.buf = buf;
274         dummy.rand_seed = hdr->rand_seed;
275         dummy.buf_filled_len = 0;
276         dummy.buflen = io_u->buflen;
277
278         fill_pattern_headers(td, &dummy, hdr->rand_seed, 1);
279
280         dump_buf(buf + hdr_offset, hdr->len, io_u->offset + hdr_offset,
281                         "expected", vc->io_u->file);
282         free(buf);
283 }
284
285 static void log_verify_failure(struct verify_header *hdr, struct vcont *vc)
286 {
287         unsigned long long offset;
288
289         offset = vc->io_u->offset;
290         offset += vc->hdr_num * hdr->len;
291         log_err("%.8s: verify failed at file %s offset %llu, length %u\n",
292                         vc->name, vc->io_u->file->file_name, offset, hdr->len);
293
294         if (vc->good_crc && vc->bad_crc) {
295                 log_err("       Expected CRC: ");
296                 hexdump(vc->good_crc, vc->crc_len);
297                 log_err("       Received CRC: ");
298                 hexdump(vc->bad_crc, vc->crc_len);
299         }
300
301         dump_verify_buffers(hdr, vc);
302 }
303
304 /*
305  * Return data area 'header_num'
306  */
307 static inline void *io_u_verify_off(struct verify_header *hdr, struct vcont *vc)
308 {
309         return vc->io_u->buf + vc->hdr_num * hdr->len + hdr_size(hdr);
310 }
311
312 static int verify_io_u_pattern(struct verify_header *hdr, struct vcont *vc)
313 {
314         struct thread_data *td = vc->td;
315         struct io_u *io_u = vc->io_u;
316         char *buf, *pattern;
317         unsigned int header_size = __hdr_size(td->o.verify);
318         unsigned int len, mod, i, size, pattern_size;
319
320         pattern = td->o.verify_pattern;
321         pattern_size = td->o.verify_pattern_bytes;
322         if (pattern_size <= 1)
323                 pattern_size = MAX_PATTERN_SIZE;
324         buf = (void *) hdr + header_size;
325         len = get_hdr_inc(td, io_u) - header_size;
326         mod = header_size % pattern_size;
327
328         for (i = 0; i < len; i += size) {
329                 size = pattern_size - mod;
330                 if (size > (len - i))
331                         size = len - i;
332                 if (memcmp(buf + i, pattern + mod, size))
333                         /* Let the slow compare find the first mismatch byte. */
334                         break;
335                 mod = 0;
336         }
337
338         for (; i < len; i++) {
339                 if (buf[i] != pattern[mod]) {
340                         unsigned int bits;
341
342                         bits = hweight8(buf[i] ^ pattern[mod]);
343                         log_err("fio: got pattern %x, wanted %x. Bad bits %d\n",
344                                 buf[i], pattern[mod], bits);
345                         log_err("fio: bad pattern block offset %u\n", i);
346                         dump_verify_buffers(hdr, vc);
347                         return EILSEQ;
348                 }
349                 mod++;
350                 if (mod == td->o.verify_pattern_bytes)
351                         mod = 0;
352         }
353
354         return 0;
355 }
356
357 static int verify_io_u_meta(struct verify_header *hdr, struct vcont *vc)
358 {
359         struct thread_data *td = vc->td;
360         struct vhdr_meta *vh = hdr_priv(hdr);
361         struct io_u *io_u = vc->io_u;
362         int ret = EILSEQ;
363
364         dprint(FD_VERIFY, "meta verify io_u %p, len %u\n", io_u, hdr->len);
365
366         if (vh->offset == io_u->offset + vc->hdr_num * td->o.verify_interval)
367                 ret = 0;
368
369         if (td->o.verify_pattern_bytes)
370                 ret |= verify_io_u_pattern(hdr, vc);
371
372         if (!ret)
373                 return 0;
374
375         vc->name = "meta";
376         log_verify_failure(hdr, vc);
377         return ret;
378 }
379
380 static int verify_io_u_sha512(struct verify_header *hdr, struct vcont *vc)
381 {
382         void *p = io_u_verify_off(hdr, vc);
383         struct vhdr_sha512 *vh = hdr_priv(hdr);
384         uint8_t sha512[128];
385         struct fio_sha512_ctx sha512_ctx = {
386                 .buf = sha512,
387         };
388
389         dprint(FD_VERIFY, "sha512 verify io_u %p, len %u\n", vc->io_u, hdr->len);
390
391         fio_sha512_init(&sha512_ctx);
392         fio_sha512_update(&sha512_ctx, p, hdr->len - hdr_size(hdr));
393
394         if (!memcmp(vh->sha512, sha512_ctx.buf, sizeof(sha512)))
395                 return 0;
396
397         vc->name = "sha512";
398         vc->good_crc = vh->sha512;
399         vc->bad_crc = sha512_ctx.buf;
400         vc->crc_len = sizeof(vh->sha512);
401         log_verify_failure(hdr, vc);
402         return EILSEQ;
403 }
404
405 static int verify_io_u_sha256(struct verify_header *hdr, struct vcont *vc)
406 {
407         void *p = io_u_verify_off(hdr, vc);
408         struct vhdr_sha256 *vh = hdr_priv(hdr);
409         uint8_t sha256[64];
410         struct fio_sha256_ctx sha256_ctx = {
411                 .buf = sha256,
412         };
413
414         dprint(FD_VERIFY, "sha256 verify io_u %p, len %u\n", vc->io_u, hdr->len);
415
416         fio_sha256_init(&sha256_ctx);
417         fio_sha256_update(&sha256_ctx, p, hdr->len - hdr_size(hdr));
418
419         if (!memcmp(vh->sha256, sha256_ctx.buf, sizeof(sha256)))
420                 return 0;
421
422         vc->name = "sha256";
423         vc->good_crc = vh->sha256;
424         vc->bad_crc = sha256_ctx.buf;
425         vc->crc_len = sizeof(vh->sha256);
426         log_verify_failure(hdr, vc);
427         return EILSEQ;
428 }
429
430 static int verify_io_u_sha1(struct verify_header *hdr, struct vcont *vc)
431 {
432         void *p = io_u_verify_off(hdr, vc);
433         struct vhdr_sha1 *vh = hdr_priv(hdr);
434         uint32_t sha1[5];
435         struct fio_sha1_ctx sha1_ctx = {
436                 .H = sha1,
437         };
438
439         dprint(FD_VERIFY, "sha1 verify io_u %p, len %u\n", vc->io_u, hdr->len);
440
441         fio_sha1_init(&sha1_ctx);
442         fio_sha1_update(&sha1_ctx, p, hdr->len - hdr_size(hdr));
443
444         if (!memcmp(vh->sha1, sha1_ctx.H, sizeof(sha1)))
445                 return 0;
446
447         vc->name = "sha1";
448         vc->good_crc = vh->sha1;
449         vc->bad_crc = sha1_ctx.H;
450         vc->crc_len = sizeof(vh->sha1);
451         log_verify_failure(hdr, vc);
452         return EILSEQ;
453 }
454
455 static int verify_io_u_crc7(struct verify_header *hdr, struct vcont *vc)
456 {
457         void *p = io_u_verify_off(hdr, vc);
458         struct vhdr_crc7 *vh = hdr_priv(hdr);
459         unsigned char c;
460
461         dprint(FD_VERIFY, "crc7 verify io_u %p, len %u\n", vc->io_u, hdr->len);
462
463         c = fio_crc7(p, hdr->len - hdr_size(hdr));
464
465         if (c == vh->crc7)
466                 return 0;
467
468         vc->name = "crc7";
469         vc->good_crc = &vh->crc7;
470         vc->bad_crc = &c;
471         vc->crc_len = 1;
472         log_verify_failure(hdr, vc);
473         return EILSEQ;
474 }
475
476 static int verify_io_u_crc16(struct verify_header *hdr, struct vcont *vc)
477 {
478         void *p = io_u_verify_off(hdr, vc);
479         struct vhdr_crc16 *vh = hdr_priv(hdr);
480         unsigned short c;
481
482         dprint(FD_VERIFY, "crc16 verify io_u %p, len %u\n", vc->io_u, hdr->len);
483
484         c = fio_crc16(p, hdr->len - hdr_size(hdr));
485
486         if (c == vh->crc16)
487                 return 0;
488
489         vc->name = "crc16";
490         vc->good_crc = &vh->crc16;
491         vc->bad_crc = &c;
492         vc->crc_len = 2;
493         log_verify_failure(hdr, vc);
494         return EILSEQ;
495 }
496
497 static int verify_io_u_crc64(struct verify_header *hdr, struct vcont *vc)
498 {
499         void *p = io_u_verify_off(hdr, vc);
500         struct vhdr_crc64 *vh = hdr_priv(hdr);
501         unsigned long long c;
502
503         dprint(FD_VERIFY, "crc64 verify io_u %p, len %u\n", vc->io_u, hdr->len);
504
505         c = fio_crc64(p, hdr->len - hdr_size(hdr));
506
507         if (c == vh->crc64)
508                 return 0;
509
510         vc->name = "crc64";
511         vc->good_crc = &vh->crc64;
512         vc->bad_crc = &c;
513         vc->crc_len = 8;
514         log_verify_failure(hdr, vc);
515         return EILSEQ;
516 }
517
518 static int verify_io_u_crc32(struct verify_header *hdr, struct vcont *vc)
519 {
520         void *p = io_u_verify_off(hdr, vc);
521         struct vhdr_crc32 *vh = hdr_priv(hdr);
522         uint32_t c;
523
524         dprint(FD_VERIFY, "crc32 verify io_u %p, len %u\n", vc->io_u, hdr->len);
525
526         c = fio_crc32(p, hdr->len - hdr_size(hdr));
527
528         if (c == vh->crc32)
529                 return 0;
530
531         vc->name = "crc32";
532         vc->good_crc = &vh->crc32;
533         vc->bad_crc = &c;
534         vc->crc_len = 4;
535         log_verify_failure(hdr, vc);
536         return EILSEQ;
537 }
538
539 static int verify_io_u_crc32c(struct verify_header *hdr, struct vcont *vc)
540 {
541         void *p = io_u_verify_off(hdr, vc);
542         struct vhdr_crc32 *vh = hdr_priv(hdr);
543         uint32_t c;
544
545         dprint(FD_VERIFY, "crc32c verify io_u %p, len %u\n", vc->io_u, hdr->len);
546
547         c = fio_crc32c(p, hdr->len - hdr_size(hdr));
548
549         if (c == vh->crc32)
550                 return 0;
551
552         vc->name = "crc32c";
553         vc->good_crc = &vh->crc32;
554         vc->bad_crc = &c;
555         vc->crc_len = 4;
556         log_verify_failure(hdr, vc);
557         return EILSEQ;
558 }
559
560 static int verify_io_u_md5(struct verify_header *hdr, struct vcont *vc)
561 {
562         void *p = io_u_verify_off(hdr, vc);
563         struct vhdr_md5 *vh = hdr_priv(hdr);
564         uint32_t hash[MD5_HASH_WORDS];
565         struct fio_md5_ctx md5_ctx = {
566                 .hash = hash,
567         };
568
569         dprint(FD_VERIFY, "md5 verify io_u %p, len %u\n", vc->io_u, hdr->len);
570
571         fio_md5_init(&md5_ctx);
572         fio_md5_update(&md5_ctx, p, hdr->len - hdr_size(hdr));
573
574         if (!memcmp(vh->md5_digest, md5_ctx.hash, sizeof(hash)))
575                 return 0;
576
577         vc->name = "md5";
578         vc->good_crc = vh->md5_digest;
579         vc->bad_crc = md5_ctx.hash;
580         vc->crc_len = sizeof(hash);
581         log_verify_failure(hdr, vc);
582         return EILSEQ;
583 }
584
585 /*
586  * Push IO verification to a separate thread
587  */
588 int verify_io_u_async(struct thread_data *td, struct io_u *io_u)
589 {
590         if (io_u->file)
591                 put_file_log(td, io_u->file);
592
593         pthread_mutex_lock(&td->io_u_lock);
594
595         if (io_u->flags & IO_U_F_IN_CUR_DEPTH) {
596                 td->cur_depth--;
597                 io_u->flags &= ~IO_U_F_IN_CUR_DEPTH;
598         }
599         flist_add_tail(&io_u->verify_list, &td->verify_list);
600         io_u->flags |= IO_U_F_FREE_DEF;
601         pthread_mutex_unlock(&td->io_u_lock);
602
603         pthread_cond_signal(&td->verify_cond);
604         return 0;
605 }
606
607 static int verify_trimmed_io_u(struct thread_data *td, struct io_u *io_u)
608 {
609         static char zero_buf[1024];
610         unsigned int this_len, len;
611         int ret = 0;
612         void *p;
613
614         if (!td->o.trim_zero)
615                 return 0;
616
617         len = io_u->buflen;
618         p = io_u->buf;
619         do {
620                 this_len = sizeof(zero_buf);
621                 if (this_len > len)
622                         this_len = len;
623                 if (memcmp(p, zero_buf, this_len)) {
624                         ret = EILSEQ;
625                         break;
626                 }
627                 len -= this_len;
628                 p += this_len;
629         } while (len);
630
631         if (!ret)
632                 return 0;
633
634         log_err("trim: verify failed at file %s offset %llu, length %lu"
635                 ", block offset %lu\n",
636                         io_u->file->file_name, io_u->offset, io_u->buflen,
637                         (unsigned long) (p - io_u->buf));
638         return ret;
639 }
640
641 static int verify_header(struct io_u *io_u, struct verify_header *hdr)
642 {
643         void *p = hdr;
644         uint32_t crc;
645
646         if (hdr->magic != FIO_HDR_MAGIC)
647                 return 0;
648         if (hdr->len > io_u->buflen) {
649                 log_err("fio: verify header exceeds buffer length (%u > %lu)\n", hdr->len, io_u->buflen);
650                 return 0;
651         }
652
653         crc = fio_crc32c(p, offsetof(struct verify_header, crc32));
654         if (crc == hdr->crc32)
655                 return 1;
656
657         log_err("fio: verify header crc %x, calculated %x\n", hdr->crc32, crc);
658         return 0;
659 }
660
661 int verify_io_u(struct thread_data *td, struct io_u *io_u)
662 {
663         struct verify_header *hdr;
664         unsigned int header_size, hdr_inc, hdr_num = 0;
665         void *p;
666         int ret;
667
668         if (td->o.verify == VERIFY_NULL || io_u->ddir != DDIR_READ)
669                 return 0;
670         if (io_u->flags & IO_U_F_TRIMMED) {
671                 ret = verify_trimmed_io_u(td, io_u);
672                 goto done;
673         }
674
675         hdr_inc = get_hdr_inc(td, io_u);
676
677         ret = 0;
678         for (p = io_u->buf; p < io_u->buf + io_u->buflen;
679              p += hdr_inc, hdr_num++) {
680                 struct vcont vc = {
681                         .io_u           = io_u,
682                         .hdr_num        = hdr_num,
683                         .td             = td,
684                 };
685                 unsigned int verify_type;
686
687                 if (ret && td->o.verify_fatal)
688                         break;
689
690                 header_size = __hdr_size(td->o.verify);
691                 if (td->o.verify_offset)
692                         memswp(p, p + td->o.verify_offset, header_size);
693                 hdr = p;
694
695                 if (!verify_header(io_u, hdr)) {
696                         log_err("verify: bad magic header %x, wanted %x at "
697                                 "file %s offset %llu, length %u\n",
698                                 hdr->magic, FIO_HDR_MAGIC,
699                                 io_u->file->file_name,
700                                 io_u->offset + hdr_num * hdr->len, hdr->len);
701                         return EILSEQ;
702                 }
703
704                 if (td->o.verify != VERIFY_NONE)
705                         verify_type = td->o.verify;
706                 else
707                         verify_type = hdr->verify_type;
708
709                 switch (verify_type) {
710                 case VERIFY_MD5:
711                         ret = verify_io_u_md5(hdr, &vc);
712                         break;
713                 case VERIFY_CRC64:
714                         ret = verify_io_u_crc64(hdr, &vc);
715                         break;
716                 case VERIFY_CRC32C:
717                 case VERIFY_CRC32C_INTEL:
718                         ret = verify_io_u_crc32c(hdr, &vc);
719                         break;
720                 case VERIFY_CRC32:
721                         ret = verify_io_u_crc32(hdr, &vc);
722                         break;
723                 case VERIFY_CRC16:
724                         ret = verify_io_u_crc16(hdr, &vc);
725                         break;
726                 case VERIFY_CRC7:
727                         ret = verify_io_u_crc7(hdr, &vc);
728                         break;
729                 case VERIFY_SHA256:
730                         ret = verify_io_u_sha256(hdr, &vc);
731                         break;
732                 case VERIFY_SHA512:
733                         ret = verify_io_u_sha512(hdr, &vc);
734                         break;
735                 case VERIFY_META:
736                         ret = verify_io_u_meta(hdr, &vc);
737                         break;
738                 case VERIFY_SHA1:
739                         ret = verify_io_u_sha1(hdr, &vc);
740                         break;
741                 case VERIFY_PATTERN:
742                         ret = verify_io_u_pattern(hdr, &vc);
743                         break;
744                 default:
745                         log_err("Bad verify type %u\n", hdr->verify_type);
746                         ret = EINVAL;
747                 }
748
749                 if (ret && verify_type != hdr->verify_type)
750                         log_err("fio: verify type mismatch (%u media, %u given)\n",
751                                         hdr->verify_type, verify_type);
752         }
753
754 done:
755         if (ret && td->o.verify_fatal)
756                 td->terminate = 1;
757
758         return ret;
759 }
760
761 static void fill_meta(struct verify_header *hdr, struct thread_data *td,
762                       struct io_u *io_u, unsigned int header_num)
763 {
764         struct vhdr_meta *vh = hdr_priv(hdr);
765
766         vh->thread = td->thread_number;
767
768         vh->time_sec = io_u->start_time.tv_sec;
769         vh->time_usec = io_u->start_time.tv_usec;
770
771         vh->numberio = td->io_issues[DDIR_WRITE];
772
773         vh->offset = io_u->offset + header_num * td->o.verify_interval;
774 }
775
776 static void fill_sha512(struct verify_header *hdr, void *p, unsigned int len)
777 {
778         struct vhdr_sha512 *vh = hdr_priv(hdr);
779         struct fio_sha512_ctx sha512_ctx = {
780                 .buf = vh->sha512,
781         };
782
783         fio_sha512_init(&sha512_ctx);
784         fio_sha512_update(&sha512_ctx, p, len);
785 }
786
787 static void fill_sha256(struct verify_header *hdr, void *p, unsigned int len)
788 {
789         struct vhdr_sha256 *vh = hdr_priv(hdr);
790         struct fio_sha256_ctx sha256_ctx = {
791                 .buf = vh->sha256,
792         };
793
794         fio_sha256_init(&sha256_ctx);
795         fio_sha256_update(&sha256_ctx, p, len);
796 }
797
798 static void fill_sha1(struct verify_header *hdr, void *p, unsigned int len)
799 {
800         struct vhdr_sha1 *vh = hdr_priv(hdr);
801         struct fio_sha1_ctx sha1_ctx = {
802                 .H = vh->sha1,
803         };
804
805         fio_sha1_init(&sha1_ctx);
806         fio_sha1_update(&sha1_ctx, p, len);
807 }
808
809 static void fill_crc7(struct verify_header *hdr, void *p, unsigned int len)
810 {
811         struct vhdr_crc7 *vh = hdr_priv(hdr);
812
813         vh->crc7 = fio_crc7(p, len);
814 }
815
816 static void fill_crc16(struct verify_header *hdr, void *p, unsigned int len)
817 {
818         struct vhdr_crc16 *vh = hdr_priv(hdr);
819
820         vh->crc16 = fio_crc16(p, len);
821 }
822
823 static void fill_crc32(struct verify_header *hdr, void *p, unsigned int len)
824 {
825         struct vhdr_crc32 *vh = hdr_priv(hdr);
826
827         vh->crc32 = fio_crc32(p, len);
828 }
829
830 static void fill_crc32c(struct verify_header *hdr, void *p, unsigned int len)
831 {
832         struct vhdr_crc32 *vh = hdr_priv(hdr);
833
834         vh->crc32 = fio_crc32c(p, len);
835 }
836
837 static void fill_crc64(struct verify_header *hdr, void *p, unsigned int len)
838 {
839         struct vhdr_crc64 *vh = hdr_priv(hdr);
840
841         vh->crc64 = fio_crc64(p, len);
842 }
843
844 static void fill_md5(struct verify_header *hdr, void *p, unsigned int len)
845 {
846         struct vhdr_md5 *vh = hdr_priv(hdr);
847         struct fio_md5_ctx md5_ctx = {
848                 .hash = (uint32_t *) vh->md5_digest,
849         };
850
851         fio_md5_init(&md5_ctx);
852         fio_md5_update(&md5_ctx, p, len);
853 }
854
855 static void populate_hdr(struct thread_data *td, struct io_u *io_u,
856                          struct verify_header *hdr, unsigned int header_num,
857                          unsigned int header_len)
858 {
859         unsigned int data_len;
860         void *data, *p;
861
862         p = (void *) hdr;
863
864         hdr->magic = FIO_HDR_MAGIC;
865         hdr->verify_type = td->o.verify;
866         hdr->len = header_len;
867         hdr->rand_seed = io_u->rand_seed;
868         hdr->crc32 = fio_crc32c(p, offsetof(struct verify_header, crc32));
869
870         data_len = header_len - hdr_size(hdr);
871
872         data = p + hdr_size(hdr);
873         switch (td->o.verify) {
874         case VERIFY_MD5:
875                 dprint(FD_VERIFY, "fill md5 io_u %p, len %u\n",
876                                                 io_u, hdr->len);
877                 fill_md5(hdr, data, data_len);
878                 break;
879         case VERIFY_CRC64:
880                 dprint(FD_VERIFY, "fill crc64 io_u %p, len %u\n",
881                                                 io_u, hdr->len);
882                 fill_crc64(hdr, data, data_len);
883                 break;
884         case VERIFY_CRC32C:
885         case VERIFY_CRC32C_INTEL:
886                 dprint(FD_VERIFY, "fill crc32c io_u %p, len %u\n",
887                                                 io_u, hdr->len);
888                 fill_crc32c(hdr, data, data_len);
889                 break;
890         case VERIFY_CRC32:
891                 dprint(FD_VERIFY, "fill crc32 io_u %p, len %u\n",
892                                                 io_u, hdr->len);
893                 fill_crc32(hdr, data, data_len);
894                 break;
895         case VERIFY_CRC16:
896                 dprint(FD_VERIFY, "fill crc16 io_u %p, len %u\n",
897                                                 io_u, hdr->len);
898                 fill_crc16(hdr, data, data_len);
899                 break;
900         case VERIFY_CRC7:
901                 dprint(FD_VERIFY, "fill crc7 io_u %p, len %u\n",
902                                                 io_u, hdr->len);
903                 fill_crc7(hdr, data, data_len);
904                 break;
905         case VERIFY_SHA256:
906                 dprint(FD_VERIFY, "fill sha256 io_u %p, len %u\n",
907                                                 io_u, hdr->len);
908                 fill_sha256(hdr, data, data_len);
909                 break;
910         case VERIFY_SHA512:
911                 dprint(FD_VERIFY, "fill sha512 io_u %p, len %u\n",
912                                                 io_u, hdr->len);
913                 fill_sha512(hdr, data, data_len);
914                 break;
915         case VERIFY_META:
916                 dprint(FD_VERIFY, "fill meta io_u %p, len %u\n",
917                                                 io_u, hdr->len);
918                 fill_meta(hdr, td, io_u, header_num);
919                 break;
920         case VERIFY_SHA1:
921                 dprint(FD_VERIFY, "fill sha1 io_u %p, len %u\n",
922                                                 io_u, hdr->len);
923                 fill_sha1(hdr, data, data_len);
924                 break;
925         case VERIFY_PATTERN:
926                 /* nothing to do here */
927                 break;
928         default:
929                 log_err("fio: bad verify type: %d\n", td->o.verify);
930                 assert(0);
931         }
932         if (td->o.verify_offset)
933                 memswp(p, p + td->o.verify_offset, hdr_size(hdr));
934 }
935
936 /*
937  * fill body of io_u->buf with random data and add a header with the
938  * checksum of choice
939  */
940 void populate_verify_io_u(struct thread_data *td, struct io_u *io_u)
941 {
942         if (td->o.verify == VERIFY_NULL)
943                 return;
944
945         fill_pattern_headers(td, io_u, 0, 0);
946 }
947
948 int get_next_verify(struct thread_data *td, struct io_u *io_u)
949 {
950         struct io_piece *ipo = NULL;
951
952         /*
953          * this io_u is from a requeue, we already filled the offsets
954          */
955         if (io_u->file)
956                 return 0;
957
958         if (!RB_EMPTY_ROOT(&td->io_hist_tree)) {
959                 struct rb_node *n = rb_first(&td->io_hist_tree);
960
961                 ipo = rb_entry(n, struct io_piece, rb_node);
962                 rb_erase(n, &td->io_hist_tree);
963                 assert(ipo->flags & IP_F_ONRB);
964                 ipo->flags &= ~IP_F_ONRB;
965         } else if (!flist_empty(&td->io_hist_list)) {
966                 ipo = flist_entry(td->io_hist_list.next, struct io_piece, list);
967                 flist_del(&ipo->list);
968                 assert(ipo->flags & IP_F_ONLIST);
969                 ipo->flags &= ~IP_F_ONLIST;
970         }
971
972         if (ipo) {
973                 td->io_hist_len--;
974
975                 io_u->offset = ipo->offset;
976                 io_u->buflen = ipo->len;
977                 io_u->file = ipo->file;
978                 io_u->flags |= IO_U_F_VER_LIST;
979
980                 if (ipo->flags & IP_F_TRIMMED)
981                         io_u->flags |= IO_U_F_TRIMMED;
982
983                 if (!fio_file_open(io_u->file)) {
984                         int r = td_io_open_file(td, io_u->file);
985
986                         if (r) {
987                                 dprint(FD_VERIFY, "failed file %s open\n",
988                                                 io_u->file->file_name);
989                                 return 1;
990                         }
991                 }
992
993                 get_file(ipo->file);
994                 assert(fio_file_open(io_u->file));
995                 io_u->ddir = DDIR_READ;
996                 io_u->xfer_buf = io_u->buf;
997                 io_u->xfer_buflen = io_u->buflen;
998
999                 remove_trim_entry(td, ipo);
1000                 free(ipo);
1001                 dprint(FD_VERIFY, "get_next_verify: ret io_u %p\n", io_u);
1002                 return 0;
1003         }
1004
1005         dprint(FD_VERIFY, "get_next_verify: empty\n");
1006         return 1;
1007 }
1008
1009 void fio_verify_init(struct thread_data *td)
1010 {
1011         if (td->o.verify == VERIFY_CRC32C_INTEL ||
1012             td->o.verify == VERIFY_CRC32C) {
1013                 crc32c_intel_probe();
1014         }
1015 }
1016
1017 static void *verify_async_thread(void *data)
1018 {
1019         struct thread_data *td = data;
1020         struct io_u *io_u;
1021         int ret = 0;
1022
1023         if (td->o.verify_cpumask_set &&
1024             fio_setaffinity(td->pid, td->o.verify_cpumask)) {
1025                 log_err("fio: failed setting verify thread affinity\n");
1026                 goto done;
1027         }
1028
1029         do {
1030                 FLIST_HEAD(list);
1031
1032                 read_barrier();
1033                 if (td->verify_thread_exit)
1034                         break;
1035
1036                 pthread_mutex_lock(&td->io_u_lock);
1037
1038                 while (flist_empty(&td->verify_list) &&
1039                        !td->verify_thread_exit) {
1040                         ret = pthread_cond_wait(&td->verify_cond,
1041                                                         &td->io_u_lock);
1042                         if (ret) {
1043                                 pthread_mutex_unlock(&td->io_u_lock);
1044                                 break;
1045                         }
1046                 }
1047
1048                 flist_splice_init(&td->verify_list, &list);
1049                 pthread_mutex_unlock(&td->io_u_lock);
1050
1051                 if (flist_empty(&list))
1052                         continue;
1053
1054                 while (!flist_empty(&list)) {
1055                         io_u = flist_entry(list.next, struct io_u, verify_list);
1056                         flist_del(&io_u->verify_list);
1057
1058                         ret = verify_io_u(td, io_u);
1059                         put_io_u(td, io_u);
1060                         if (!ret)
1061                                 continue;
1062                         if (td_non_fatal_error(td, ERROR_TYPE_VERIFY_BIT, ret)) {
1063                                 update_error_count(td, ret);
1064                                 td_clear_error(td);
1065                                 ret = 0;
1066                         }
1067                 }
1068         } while (!ret);
1069
1070         if (ret) {
1071                 td_verror(td, ret, "async_verify");
1072                 if (td->o.verify_fatal)
1073                         td->terminate = 1;
1074         }
1075
1076 done:
1077         pthread_mutex_lock(&td->io_u_lock);
1078         td->nr_verify_threads--;
1079         pthread_mutex_unlock(&td->io_u_lock);
1080
1081         pthread_cond_signal(&td->free_cond);
1082         return NULL;
1083 }
1084
1085 int verify_async_init(struct thread_data *td)
1086 {
1087         int i, ret;
1088         pthread_attr_t attr;
1089
1090         pthread_attr_init(&attr);
1091         pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
1092
1093         td->verify_thread_exit = 0;
1094
1095         td->verify_threads = malloc(sizeof(pthread_t) * td->o.verify_async);
1096         for (i = 0; i < td->o.verify_async; i++) {
1097                 ret = pthread_create(&td->verify_threads[i], &attr,
1098                                         verify_async_thread, td);
1099                 if (ret) {
1100                         log_err("fio: async verify creation failed: %s\n",
1101                                         strerror(ret));
1102                         break;
1103                 }
1104                 ret = pthread_detach(td->verify_threads[i]);
1105                 if (ret) {
1106                         log_err("fio: async verify thread detach failed: %s\n",
1107                                         strerror(ret));
1108                         break;
1109                 }
1110                 td->nr_verify_threads++;
1111         }
1112
1113         pthread_attr_destroy(&attr);
1114
1115         if (i != td->o.verify_async) {
1116                 log_err("fio: only %d verify threads started, exiting\n", i);
1117                 td->verify_thread_exit = 1;
1118                 write_barrier();
1119                 pthread_cond_broadcast(&td->verify_cond);
1120                 return 1;
1121         }
1122
1123         return 0;
1124 }
1125
1126 void verify_async_exit(struct thread_data *td)
1127 {
1128         td->verify_thread_exit = 1;
1129         write_barrier();
1130         pthread_cond_broadcast(&td->verify_cond);
1131
1132         pthread_mutex_lock(&td->io_u_lock);
1133
1134         while (td->nr_verify_threads)
1135                 pthread_cond_wait(&td->free_cond, &td->io_u_lock);
1136
1137         pthread_mutex_unlock(&td->io_u_lock);
1138         free(td->verify_threads);
1139         td->verify_threads = NULL;
1140 }