Add section 9 to HOWTO table of contents.
[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
277         fill_pattern_headers(td, &dummy, hdr->rand_seed, 1);
278
279         dump_buf(buf + hdr_offset, hdr->len, io_u->offset + hdr_offset,
280                         "expected", vc->io_u->file);
281         free(buf);
282 }
283
284 static void log_verify_failure(struct verify_header *hdr, struct vcont *vc)
285 {
286         unsigned long long offset;
287
288         offset = vc->io_u->offset;
289         offset += vc->hdr_num * hdr->len;
290         log_err("%.8s: verify failed at file %s offset %llu, length %u\n",
291                         vc->name, vc->io_u->file->file_name, offset, hdr->len);
292
293         if (vc->good_crc && vc->bad_crc) {
294                 log_err("       Expected CRC: ");
295                 hexdump(vc->good_crc, vc->crc_len);
296                 log_err("       Received CRC: ");
297                 hexdump(vc->bad_crc, vc->crc_len);
298         }
299
300         dump_verify_buffers(hdr, vc);
301 }
302
303 /*
304  * Return data area 'header_num'
305  */
306 static inline void *io_u_verify_off(struct verify_header *hdr, struct vcont *vc)
307 {
308         return vc->io_u->buf + vc->hdr_num * hdr->len + hdr_size(hdr);
309 }
310
311 static int verify_io_u_pattern(struct verify_header *hdr, struct vcont *vc)
312 {
313         struct thread_data *td = vc->td;
314         struct io_u *io_u = vc->io_u;
315         char *buf, *pattern;
316         unsigned int header_size = __hdr_size(td->o.verify);
317         unsigned int len, mod, i, size, pattern_size;
318
319         pattern = td->o.verify_pattern;
320         pattern_size = td->o.verify_pattern_bytes;
321         if (pattern_size <= 1)
322                 pattern_size = MAX_PATTERN_SIZE;
323         buf = (void *) hdr + header_size;
324         len = get_hdr_inc(td, io_u) - header_size;
325         mod = header_size % pattern_size;
326
327         for (i = 0; i < len; i += size) {
328                 size = pattern_size - mod;
329                 if (size > (len - i))
330                         size = len - i;
331                 if (memcmp(buf + i, pattern + mod, size))
332                         /* Let the slow compare find the first mismatch byte. */
333                         break;
334                 mod = 0;
335         }
336
337         for (; i < len; i++) {
338                 if (buf[i] != pattern[mod]) {
339                         unsigned int bits;
340
341                         bits = hweight8(buf[i] ^ pattern[mod]);
342                         log_err("fio: got pattern %x, wanted %x. Bad bits %d\n",
343                                 buf[i], pattern[mod], bits);
344                         log_err("fio: bad pattern block offset %u\n", i);
345                         dump_verify_buffers(hdr, vc);
346                         return EILSEQ;
347                 }
348                 mod++;
349                 if (mod == td->o.verify_pattern_bytes)
350                         mod = 0;
351         }
352
353         return 0;
354 }
355
356 static int verify_io_u_meta(struct verify_header *hdr, struct vcont *vc)
357 {
358         struct thread_data *td = vc->td;
359         struct vhdr_meta *vh = hdr_priv(hdr);
360         struct io_u *io_u = vc->io_u;
361         int ret = EILSEQ;
362
363         dprint(FD_VERIFY, "meta verify io_u %p, len %u\n", io_u, hdr->len);
364
365         if (vh->offset == io_u->offset + vc->hdr_num * td->o.verify_interval)
366                 ret = 0;
367
368         if (td->o.verify_pattern_bytes)
369                 ret |= verify_io_u_pattern(hdr, vc);
370
371         if (!ret)
372                 return 0;
373
374         vc->name = "meta";
375         log_verify_failure(hdr, vc);
376         return ret;
377 }
378
379 static int verify_io_u_sha512(struct verify_header *hdr, struct vcont *vc)
380 {
381         void *p = io_u_verify_off(hdr, vc);
382         struct vhdr_sha512 *vh = hdr_priv(hdr);
383         uint8_t sha512[128];
384         struct fio_sha512_ctx sha512_ctx = {
385                 .buf = sha512,
386         };
387
388         dprint(FD_VERIFY, "sha512 verify io_u %p, len %u\n", vc->io_u, hdr->len);
389
390         fio_sha512_init(&sha512_ctx);
391         fio_sha512_update(&sha512_ctx, p, hdr->len - hdr_size(hdr));
392
393         if (!memcmp(vh->sha512, sha512_ctx.buf, sizeof(sha512)))
394                 return 0;
395
396         vc->name = "sha512";
397         vc->good_crc = vh->sha512;
398         vc->bad_crc = sha512_ctx.buf;
399         vc->crc_len = sizeof(vh->sha512);
400         log_verify_failure(hdr, vc);
401         return EILSEQ;
402 }
403
404 static int verify_io_u_sha256(struct verify_header *hdr, struct vcont *vc)
405 {
406         void *p = io_u_verify_off(hdr, vc);
407         struct vhdr_sha256 *vh = hdr_priv(hdr);
408         uint8_t sha256[64];
409         struct fio_sha256_ctx sha256_ctx = {
410                 .buf = sha256,
411         };
412
413         dprint(FD_VERIFY, "sha256 verify io_u %p, len %u\n", vc->io_u, hdr->len);
414
415         fio_sha256_init(&sha256_ctx);
416         fio_sha256_update(&sha256_ctx, p, hdr->len - hdr_size(hdr));
417
418         if (!memcmp(vh->sha256, sha256_ctx.buf, sizeof(sha256)))
419                 return 0;
420
421         vc->name = "sha256";
422         vc->good_crc = vh->sha256;
423         vc->bad_crc = sha256_ctx.buf;
424         vc->crc_len = sizeof(vh->sha256);
425         log_verify_failure(hdr, vc);
426         return EILSEQ;
427 }
428
429 static int verify_io_u_sha1(struct verify_header *hdr, struct vcont *vc)
430 {
431         void *p = io_u_verify_off(hdr, vc);
432         struct vhdr_sha1 *vh = hdr_priv(hdr);
433         uint32_t sha1[5];
434         struct fio_sha1_ctx sha1_ctx = {
435                 .H = sha1,
436         };
437
438         dprint(FD_VERIFY, "sha1 verify io_u %p, len %u\n", vc->io_u, hdr->len);
439
440         fio_sha1_init(&sha1_ctx);
441         fio_sha1_update(&sha1_ctx, p, hdr->len - hdr_size(hdr));
442
443         if (!memcmp(vh->sha1, sha1_ctx.H, sizeof(sha1)))
444                 return 0;
445
446         vc->name = "sha1";
447         vc->good_crc = vh->sha1;
448         vc->bad_crc = sha1_ctx.H;
449         vc->crc_len = sizeof(vh->sha1);
450         log_verify_failure(hdr, vc);
451         return EILSEQ;
452 }
453
454 static int verify_io_u_crc7(struct verify_header *hdr, struct vcont *vc)
455 {
456         void *p = io_u_verify_off(hdr, vc);
457         struct vhdr_crc7 *vh = hdr_priv(hdr);
458         unsigned char c;
459
460         dprint(FD_VERIFY, "crc7 verify io_u %p, len %u\n", vc->io_u, hdr->len);
461
462         c = fio_crc7(p, hdr->len - hdr_size(hdr));
463
464         if (c == vh->crc7)
465                 return 0;
466
467         vc->name = "crc7";
468         vc->good_crc = &vh->crc7;
469         vc->bad_crc = &c;
470         vc->crc_len = 1;
471         log_verify_failure(hdr, vc);
472         return EILSEQ;
473 }
474
475 static int verify_io_u_crc16(struct verify_header *hdr, struct vcont *vc)
476 {
477         void *p = io_u_verify_off(hdr, vc);
478         struct vhdr_crc16 *vh = hdr_priv(hdr);
479         unsigned short c;
480
481         dprint(FD_VERIFY, "crc16 verify io_u %p, len %u\n", vc->io_u, hdr->len);
482
483         c = fio_crc16(p, hdr->len - hdr_size(hdr));
484
485         if (c == vh->crc16)
486                 return 0;
487
488         vc->name = "crc16";
489         vc->good_crc = &vh->crc16;
490         vc->bad_crc = &c;
491         vc->crc_len = 2;
492         log_verify_failure(hdr, vc);
493         return EILSEQ;
494 }
495
496 static int verify_io_u_crc64(struct verify_header *hdr, struct vcont *vc)
497 {
498         void *p = io_u_verify_off(hdr, vc);
499         struct vhdr_crc64 *vh = hdr_priv(hdr);
500         unsigned long long c;
501
502         dprint(FD_VERIFY, "crc64 verify io_u %p, len %u\n", vc->io_u, hdr->len);
503
504         c = fio_crc64(p, hdr->len - hdr_size(hdr));
505
506         if (c == vh->crc64)
507                 return 0;
508
509         vc->name = "crc64";
510         vc->good_crc = &vh->crc64;
511         vc->bad_crc = &c;
512         vc->crc_len = 8;
513         log_verify_failure(hdr, vc);
514         return EILSEQ;
515 }
516
517 static int verify_io_u_crc32(struct verify_header *hdr, struct vcont *vc)
518 {
519         void *p = io_u_verify_off(hdr, vc);
520         struct vhdr_crc32 *vh = hdr_priv(hdr);
521         uint32_t c;
522
523         dprint(FD_VERIFY, "crc32 verify io_u %p, len %u\n", vc->io_u, hdr->len);
524
525         c = fio_crc32(p, hdr->len - hdr_size(hdr));
526
527         if (c == vh->crc32)
528                 return 0;
529
530         vc->name = "crc32";
531         vc->good_crc = &vh->crc32;
532         vc->bad_crc = &c;
533         vc->crc_len = 4;
534         log_verify_failure(hdr, vc);
535         return EILSEQ;
536 }
537
538 static int verify_io_u_crc32c(struct verify_header *hdr, struct vcont *vc)
539 {
540         void *p = io_u_verify_off(hdr, vc);
541         struct vhdr_crc32 *vh = hdr_priv(hdr);
542         uint32_t c;
543
544         dprint(FD_VERIFY, "crc32c verify io_u %p, len %u\n", vc->io_u, hdr->len);
545
546         c = fio_crc32c(p, hdr->len - hdr_size(hdr));
547
548         if (c == vh->crc32)
549                 return 0;
550
551         vc->name = "crc32c";
552         vc->good_crc = &vh->crc32;
553         vc->bad_crc = &c;
554         vc->crc_len = 4;
555         log_verify_failure(hdr, vc);
556         return EILSEQ;
557 }
558
559 static int verify_io_u_md5(struct verify_header *hdr, struct vcont *vc)
560 {
561         void *p = io_u_verify_off(hdr, vc);
562         struct vhdr_md5 *vh = hdr_priv(hdr);
563         uint32_t hash[MD5_HASH_WORDS];
564         struct fio_md5_ctx md5_ctx = {
565                 .hash = hash,
566         };
567
568         dprint(FD_VERIFY, "md5 verify io_u %p, len %u\n", vc->io_u, hdr->len);
569
570         fio_md5_init(&md5_ctx);
571         fio_md5_update(&md5_ctx, p, hdr->len - hdr_size(hdr));
572
573         if (!memcmp(vh->md5_digest, md5_ctx.hash, sizeof(hash)))
574                 return 0;
575
576         vc->name = "md5";
577         vc->good_crc = vh->md5_digest;
578         vc->bad_crc = md5_ctx.hash;
579         vc->crc_len = sizeof(hash);
580         log_verify_failure(hdr, vc);
581         return EILSEQ;
582 }
583
584 /*
585  * Push IO verification to a separate thread
586  */
587 int verify_io_u_async(struct thread_data *td, struct io_u *io_u)
588 {
589         if (io_u->file)
590                 put_file_log(td, io_u->file);
591
592         pthread_mutex_lock(&td->io_u_lock);
593
594         if (io_u->flags & IO_U_F_IN_CUR_DEPTH) {
595                 td->cur_depth--;
596                 io_u->flags &= ~IO_U_F_IN_CUR_DEPTH;
597         }
598         flist_del(&io_u->list);
599         flist_add_tail(&io_u->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 static void *verify_async_thread(void *data)
1010 {
1011         struct thread_data *td = data;
1012         struct io_u *io_u;
1013         int ret = 0;
1014
1015         if (td->o.verify_cpumask_set &&
1016             fio_setaffinity(td->pid, td->o.verify_cpumask)) {
1017                 log_err("fio: failed setting verify thread affinity\n");
1018                 goto done;
1019         }
1020
1021         do {
1022                 FLIST_HEAD(list);
1023
1024                 read_barrier();
1025                 if (td->verify_thread_exit)
1026                         break;
1027
1028                 pthread_mutex_lock(&td->io_u_lock);
1029
1030                 while (flist_empty(&td->verify_list) &&
1031                        !td->verify_thread_exit) {
1032                         ret = pthread_cond_wait(&td->verify_cond,
1033                                                         &td->io_u_lock);
1034                         if (ret) {
1035                                 pthread_mutex_unlock(&td->io_u_lock);
1036                                 break;
1037                         }
1038                 }
1039
1040                 flist_splice_init(&td->verify_list, &list);
1041                 pthread_mutex_unlock(&td->io_u_lock);
1042
1043                 if (flist_empty(&list))
1044                         continue;
1045
1046                 while (!flist_empty(&list)) {
1047                         io_u = flist_entry(list.next, struct io_u, list);
1048                         flist_del_init(&io_u->list);
1049
1050                         ret = verify_io_u(td, io_u);
1051                         put_io_u(td, io_u);
1052                         if (!ret)
1053                                 continue;
1054                         if (td_non_fatal_error(td, ERROR_TYPE_VERIFY_BIT, ret)) {
1055                                 update_error_count(td, ret);
1056                                 td_clear_error(td);
1057                                 ret = 0;
1058                         }
1059                 }
1060         } while (!ret);
1061
1062         if (ret) {
1063                 td_verror(td, ret, "async_verify");
1064                 if (td->o.verify_fatal)
1065                         td->terminate = 1;
1066         }
1067
1068 done:
1069         pthread_mutex_lock(&td->io_u_lock);
1070         td->nr_verify_threads--;
1071         pthread_mutex_unlock(&td->io_u_lock);
1072
1073         pthread_cond_signal(&td->free_cond);
1074         return NULL;
1075 }
1076
1077 int verify_async_init(struct thread_data *td)
1078 {
1079         int i, ret;
1080         pthread_attr_t attr;
1081
1082         pthread_attr_init(&attr);
1083         pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
1084
1085         td->verify_thread_exit = 0;
1086
1087         td->verify_threads = malloc(sizeof(pthread_t) * td->o.verify_async);
1088         for (i = 0; i < td->o.verify_async; i++) {
1089                 ret = pthread_create(&td->verify_threads[i], &attr,
1090                                         verify_async_thread, td);
1091                 if (ret) {
1092                         log_err("fio: async verify creation failed: %s\n",
1093                                         strerror(ret));
1094                         break;
1095                 }
1096                 ret = pthread_detach(td->verify_threads[i]);
1097                 if (ret) {
1098                         log_err("fio: async verify thread detach failed: %s\n",
1099                                         strerror(ret));
1100                         break;
1101                 }
1102                 td->nr_verify_threads++;
1103         }
1104
1105         pthread_attr_destroy(&attr);
1106
1107         if (i != td->o.verify_async) {
1108                 log_err("fio: only %d verify threads started, exiting\n", i);
1109                 td->verify_thread_exit = 1;
1110                 write_barrier();
1111                 pthread_cond_broadcast(&td->verify_cond);
1112                 return 1;
1113         }
1114
1115         return 0;
1116 }
1117
1118 void verify_async_exit(struct thread_data *td)
1119 {
1120         td->verify_thread_exit = 1;
1121         write_barrier();
1122         pthread_cond_broadcast(&td->verify_cond);
1123
1124         pthread_mutex_lock(&td->io_u_lock);
1125
1126         while (td->nr_verify_threads)
1127                 pthread_cond_wait(&td->free_cond, &td->io_u_lock);
1128
1129         pthread_mutex_unlock(&td->io_u_lock);
1130         free(td->verify_threads);
1131         td->verify_threads = NULL;
1132 }