blob: c9f2374391d6c74eb6278406bc50e63270149c67 [file] [log] [blame]
Jens Axboee29d1b72006-10-18 15:43:15 +02001/*
2 * IO verification helpers
3 */
4#include <unistd.h>
5#include <fcntl.h>
6#include <string.h>
Jens Axboe97af62c2007-05-22 11:12:13 +02007#include <assert.h>
Jens Axboee29d1b72006-10-18 15:43:15 +02008
9#include "fio.h"
Jens Axboee29d1b72006-10-18 15:43:15 +020010
Jens Axboeeef6eea2007-07-30 12:27:58 +020011#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"
Jens Axboecd14cc12007-07-30 10:59:33 +020018
Jens Axboe90059d62007-07-30 09:33:12 +020019static void fill_random_bytes(struct thread_data *td, void *p, unsigned int len)
Jens Axboee29d1b72006-10-18 15:43:15 +020020{
21 unsigned int todo;
Jens Axboe4c5946c2007-07-26 11:55:10 +020022 int r;
Jens Axboee29d1b72006-10-18 15:43:15 +020023
24 while (len) {
Jens Axboe4c5946c2007-07-26 11:55:10 +020025 r = os_random_long(&td->verify_state);
Jens Axboee29d1b72006-10-18 15:43:15 +020026
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
Jens Axboe90059d62007-07-30 09:33:12 +020042static void fill_pattern(struct thread_data *td, void *p, unsigned int len)
43{
44 switch (td->o.verify_pattern_bytes) {
45 case 0:
Jens Axboebd6f78b2008-02-01 20:27:52 +010046 dprint(FD_VERIFY, "fill random bytes len=%u\n", len);
Jens Axboe90059d62007-07-30 09:33:12 +020047 fill_random_bytes(td, p, len);
48 break;
49 case 1:
Jens Axboebd6f78b2008-02-01 20:27:52 +010050 dprint(FD_VERIFY, "fill verify pattern b=0 len=%u\n", len);
Jens Axboe90059d62007-07-30 09:33:12 +020051 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
Jens Axboebd6f78b2008-02-01 20:27:52 +010061 dprint(FD_VERIFY, "fill verify pattern b=%d len=%u\n",
62 td->o.verify_pattern_bytes, len);
63
Jens Axboe90059d62007-07-30 09:33:12 +020064 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
Jens Axboe4764aec2007-08-23 09:03:38 +020089static void memswp(void *buf1, void *buf2, unsigned int len)
Shawn Lewis546a9142007-07-28 21:11:37 +020090{
Shawn Lewisdee6de72007-08-02 22:17:52 +020091 char swap[200];
92
93 assert(len <= sizeof(swap));
Jens Axboe90059d62007-07-30 09:33:12 +020094
Shawn Lewis546a9142007-07-28 21:11:37 +020095 memcpy(&swap, buf1, len);
96 memcpy(buf1, buf2, len);
97 memcpy(buf2, &swap, len);
98}
99
Jens Axboee29d1b72006-10-18 15:43:15 +0200100static void hexdump(void *buffer, int len)
101{
102 unsigned char *p = buffer;
103 int i;
104
105 for (i = 0; i < len; i++)
Jens Axboe6d861442007-03-15 09:22:23 +0100106 log_info("%02x", p[i]);
107 log_info("\n");
Jens Axboee29d1b72006-10-18 15:43:15 +0200108}
109
Jens Axboed9f2caf2007-07-28 21:22:03 +0200110/*
Jens Axboe87677832007-07-30 12:08:14 +0200111 * Prepare for seperation of verify_header and checksum header
112 */
Jens Axboe546dfd92007-07-30 12:23:05 +0200113static inline unsigned int __hdr_size(int verify_type)
Jens Axboe87677832007-07-30 12:08:14 +0200114{
Jens Axboe546dfd92007-07-30 12:23:05 +0200115 unsigned int len;
Jens Axboe87677832007-07-30 12:08:14 +0200116
Jens Axboe546dfd92007-07-30 12:23:05 +0200117 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;
Shawn Lewis7437ee82007-08-02 21:05:58 +0200143 case VERIFY_META:
144 len = sizeof(struct vhdr_meta);
145 break;
Jens Axboe546dfd92007-07-30 12:23:05 +0200146 default:
147 log_err("fio: unknown verify header!\n");
148 assert(0);
149 }
150
151 return len + sizeof(struct verify_header);
Jens Axboe87677832007-07-30 12:08:14 +0200152}
153
154static inline unsigned int hdr_size(struct verify_header *hdr)
155{
Jens Axboe546dfd92007-07-30 12:23:05 +0200156 return __hdr_size(hdr->verify_type);
157}
158
159static void *hdr_priv(struct verify_header *hdr)
160{
161 void *priv = hdr;
162
163 return priv + sizeof(struct verify_header);
Jens Axboe87677832007-07-30 12:08:14 +0200164}
165
166/*
Jens Axboed9f2caf2007-07-28 21:22:03 +0200167 * Return data area 'header_num'
168 */
169static inline void *io_u_verify_off(struct verify_header *hdr,
170 struct io_u *io_u,
171 unsigned char header_num)
172{
Jens Axboe87677832007-07-30 12:08:14 +0200173 return io_u->buf + header_num * hdr->len + hdr_size(hdr);
Jens Axboed9f2caf2007-07-28 21:22:03 +0200174}
175
Shawn Lewis7437ee82007-08-02 21:05:58 +0200176static 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
Jens Axboebd6f78b2008-02-01 20:27:52 +0100181 dprint(FD_VERIFY, "meta verify io_u %p, len %u\n", io_u, hdr->len);
182
Shawn Lewis7437ee82007-08-02 21:05:58 +0200183 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);
Jens Axboed16d4e02007-09-06 16:16:44 +0200187 return EIO;
Shawn Lewis7437ee82007-08-02 21:05:58 +0200188 }
189
190 return 0;
191}
192
Jens Axboecd14cc12007-07-30 10:59:33 +0200193static 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);
Jens Axboe546dfd92007-07-30 12:23:05 +0200197 struct vhdr_sha512 *vh = hdr_priv(hdr);
Jens Axboecd14cc12007-07-30 10:59:33 +0200198 uint8_t sha512[128];
199 struct sha512_ctx sha512_ctx = {
200 .buf = sha512,
201 };
202
Jens Axboebd6f78b2008-02-01 20:27:52 +0100203 dprint(FD_VERIFY, "sha512 verify io_u %p, len %u\n", io_u, hdr->len);
204
Jens Axboecd14cc12007-07-30 10:59:33 +0200205 sha512_init(&sha512_ctx);
Jens Axboe87677832007-07-30 12:08:14 +0200206 sha512_update(&sha512_ctx, p, hdr->len - hdr_size(hdr));
Jens Axboecd14cc12007-07-30 10:59:33 +0200207
Jens Axboe546dfd92007-07-30 12:23:05 +0200208 if (memcmp(vh->sha512, sha512_ctx.buf, sizeof(sha512))) {
Jens Axboecd14cc12007-07-30 10:59:33 +0200209 log_err("sha512: verify failed at %llu/%u\n",
210 io_u->offset + header_num * hdr->len,
211 hdr->len);
Jens Axboe546dfd92007-07-30 12:23:05 +0200212 hexdump(vh->sha512, sizeof(vh->sha512));
Jens Axboecd14cc12007-07-30 10:59:33 +0200213 hexdump(sha512_ctx.buf, sizeof(sha512));
Jens Axboed16d4e02007-09-06 16:16:44 +0200214 return EIO;
Jens Axboecd14cc12007-07-30 10:59:33 +0200215 }
216
217 return 0;
218}
219
220static 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);
Jens Axboe546dfd92007-07-30 12:23:05 +0200224 struct vhdr_sha256 *vh = hdr_priv(hdr);
Jens Axboecd14cc12007-07-30 10:59:33 +0200225 uint8_t sha256[128];
226 struct sha256_ctx sha256_ctx = {
227 .buf = sha256,
228 };
229
Jens Axboebd6f78b2008-02-01 20:27:52 +0100230 dprint(FD_VERIFY, "sha256 verify io_u %p, len %u\n", io_u, hdr->len);
231
Jens Axboecd14cc12007-07-30 10:59:33 +0200232 sha256_init(&sha256_ctx);
Jens Axboe87677832007-07-30 12:08:14 +0200233 sha256_update(&sha256_ctx, p, hdr->len - hdr_size(hdr));
Jens Axboecd14cc12007-07-30 10:59:33 +0200234
Jens Axboe546dfd92007-07-30 12:23:05 +0200235 if (memcmp(vh->sha256, sha256_ctx.buf, sizeof(sha256))) {
Jens Axboecd14cc12007-07-30 10:59:33 +0200236 log_err("sha256: verify failed at %llu/%u\n",
237 io_u->offset + header_num * hdr->len,
238 hdr->len);
Jens Axboe546dfd92007-07-30 12:23:05 +0200239 hexdump(vh->sha256, sizeof(vh->sha256));
Jens Axboecd14cc12007-07-30 10:59:33 +0200240 hexdump(sha256_ctx.buf, sizeof(sha256));
Jens Axboed16d4e02007-09-06 16:16:44 +0200241 return EIO;
Jens Axboecd14cc12007-07-30 10:59:33 +0200242 }
243
244 return 0;
245}
246
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200247static int verify_io_u_crc7(struct verify_header *hdr, struct io_u *io_u,
248 unsigned char header_num)
Jens Axboe1e154bd2007-07-27 09:52:40 +0200249{
Jens Axboed9f2caf2007-07-28 21:22:03 +0200250 void *p = io_u_verify_off(hdr, io_u, header_num);
Jens Axboe546dfd92007-07-30 12:23:05 +0200251 struct vhdr_crc7 *vh = hdr_priv(hdr);
Jens Axboe1e154bd2007-07-27 09:52:40 +0200252 unsigned char c;
253
Jens Axboebd6f78b2008-02-01 20:27:52 +0100254 dprint(FD_VERIFY, "crc7 verify io_u %p, len %u\n", io_u, hdr->len);
255
Jens Axboe87677832007-07-30 12:08:14 +0200256 c = crc7(p, hdr->len - hdr_size(hdr));
Jens Axboe1e154bd2007-07-27 09:52:40 +0200257
Jens Axboe546dfd92007-07-30 12:23:05 +0200258 if (c != vh->crc7) {
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200259 log_err("crc7: verify failed at %llu/%u\n",
260 io_u->offset + header_num * hdr->len,
261 hdr->len);
Jens Axboe546dfd92007-07-30 12:23:05 +0200262 log_err("crc7: wanted %x, got %x\n", vh->crc7, c);
Jens Axboed16d4e02007-09-06 16:16:44 +0200263 return EIO;
Jens Axboe1e154bd2007-07-27 09:52:40 +0200264 }
265
266 return 0;
267}
268
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200269static int verify_io_u_crc16(struct verify_header *hdr, struct io_u *io_u,
270 unsigned int header_num)
Jens Axboe969f7ed2007-07-27 09:07:17 +0200271{
Jens Axboed9f2caf2007-07-28 21:22:03 +0200272 void *p = io_u_verify_off(hdr, io_u, header_num);
Jens Axboe546dfd92007-07-30 12:23:05 +0200273 struct vhdr_crc16 *vh = hdr_priv(hdr);
Jens Axboe969f7ed2007-07-27 09:07:17 +0200274 unsigned short c;
275
Jens Axboebd6f78b2008-02-01 20:27:52 +0100276 dprint(FD_VERIFY, "crc16 verify io_u %p, len %u\n", io_u, hdr->len);
277
Jens Axboe87677832007-07-30 12:08:14 +0200278 c = crc16(p, hdr->len - hdr_size(hdr));
Jens Axboe969f7ed2007-07-27 09:07:17 +0200279
Jens Axboe546dfd92007-07-30 12:23:05 +0200280 if (c != vh->crc16) {
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200281 log_err("crc16: verify failed at %llu/%u\n",
282 io_u->offset + header_num * hdr->len,
283 hdr->len);
Jens Axboe546dfd92007-07-30 12:23:05 +0200284 log_err("crc16: wanted %x, got %x\n", vh->crc16, c);
Jens Axboed16d4e02007-09-06 16:16:44 +0200285 return EIO;
Jens Axboe969f7ed2007-07-27 09:07:17 +0200286 }
287
288 return 0;
289}
290
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200291static int verify_io_u_crc64(struct verify_header *hdr, struct io_u *io_u,
292 unsigned int header_num)
Jens Axboed77a7af2007-07-27 15:35:06 +0200293{
Jens Axboed9f2caf2007-07-28 21:22:03 +0200294 void *p = io_u_verify_off(hdr, io_u, header_num);
Jens Axboe546dfd92007-07-30 12:23:05 +0200295 struct vhdr_crc64 *vh = hdr_priv(hdr);
Jens Axboed77a7af2007-07-27 15:35:06 +0200296 unsigned long long c;
297
Jens Axboebd6f78b2008-02-01 20:27:52 +0100298 dprint(FD_VERIFY, "crc64 verify io_u %p, len %u\n", io_u, hdr->len);
299
Jens Axboe87677832007-07-30 12:08:14 +0200300 c = crc64(p, hdr->len - hdr_size(hdr));
Jens Axboed77a7af2007-07-27 15:35:06 +0200301
Jens Axboe546dfd92007-07-30 12:23:05 +0200302 if (c != vh->crc64) {
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200303 log_err("crc64: verify failed at %llu/%u\n",
304 io_u->offset + header_num * hdr->len,
305 hdr->len);
Jens Axboe546dfd92007-07-30 12:23:05 +0200306 log_err("crc64: wanted %llx, got %llx\n", (unsigned long long) vh->crc64, c);
Jens Axboed16d4e02007-09-06 16:16:44 +0200307 return EIO;
Jens Axboed77a7af2007-07-27 15:35:06 +0200308 }
309
310 return 0;
311}
312
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200313static int verify_io_u_crc32(struct verify_header *hdr, struct io_u *io_u,
314 unsigned int header_num)
Jens Axboee29d1b72006-10-18 15:43:15 +0200315{
Jens Axboed9f2caf2007-07-28 21:22:03 +0200316 void *p = io_u_verify_off(hdr, io_u, header_num);
Jens Axboe546dfd92007-07-30 12:23:05 +0200317 struct vhdr_crc32 *vh = hdr_priv(hdr);
318 uint32_t c;
Jens Axboee29d1b72006-10-18 15:43:15 +0200319
Jens Axboebd6f78b2008-02-01 20:27:52 +0100320 dprint(FD_VERIFY, "crc32 verify io_u %p, len %u\n", io_u, hdr->len);
321
Jens Axboe87677832007-07-30 12:08:14 +0200322 c = crc32(p, hdr->len - hdr_size(hdr));
Jens Axboee29d1b72006-10-18 15:43:15 +0200323
Jens Axboe546dfd92007-07-30 12:23:05 +0200324 if (c != vh->crc32) {
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200325 log_err("crc32: verify failed at %llu/%u\n",
326 io_u->offset + header_num * hdr->len,
327 hdr->len);
Jens Axboe546dfd92007-07-30 12:23:05 +0200328 log_err("crc32: wanted %x, got %x\n", vh->crc32, c);
Jens Axboed16d4e02007-09-06 16:16:44 +0200329 return EIO;
Jens Axboee29d1b72006-10-18 15:43:15 +0200330 }
331
332 return 0;
333}
334
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200335static int verify_io_u_md5(struct verify_header *hdr, struct io_u *io_u,
336 unsigned int header_num)
Jens Axboee29d1b72006-10-18 15:43:15 +0200337{
Jens Axboed9f2caf2007-07-28 21:22:03 +0200338 void *p = io_u_verify_off(hdr, io_u, header_num);
Jens Axboe546dfd92007-07-30 12:23:05 +0200339 struct vhdr_md5 *vh = hdr_priv(hdr);
Jens Axboe8c432322007-07-27 13:16:24 +0200340 uint32_t hash[MD5_HASH_WORDS];
341 struct md5_ctx md5_ctx = {
342 .hash = hash,
343 };
Jens Axboee29d1b72006-10-18 15:43:15 +0200344
Jens Axboebd6f78b2008-02-01 20:27:52 +0100345 dprint(FD_VERIFY, "md5 verify io_u %p, len %u\n", io_u, hdr->len);
346
Jens Axboe61f821f2007-07-30 10:18:06 +0200347 md5_init(&md5_ctx);
Jens Axboe87677832007-07-30 12:08:14 +0200348 md5_update(&md5_ctx, p, hdr->len - hdr_size(hdr));
Jens Axboee29d1b72006-10-18 15:43:15 +0200349
Jens Axboe546dfd92007-07-30 12:23:05 +0200350 if (memcmp(vh->md5_digest, md5_ctx.hash, sizeof(hash))) {
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200351 log_err("md5: verify failed at %llu/%u\n",
352 io_u->offset + header_num * hdr->len,
353 hdr->len);
Jens Axboe546dfd92007-07-30 12:23:05 +0200354 hexdump(vh->md5_digest, sizeof(vh->md5_digest));
Jens Axboe8c432322007-07-27 13:16:24 +0200355 hexdump(md5_ctx.hash, sizeof(hash));
Jens Axboed16d4e02007-09-06 16:16:44 +0200356 return EIO;
Jens Axboee29d1b72006-10-18 15:43:15 +0200357 }
358
359 return 0;
360}
361
Jens Axboe3f199b02007-08-09 10:16:31 +0200362static 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
Shawn Lewisa944e332007-08-02 22:18:29 +0200370int verify_io_u_pattern(unsigned long pattern, unsigned long pattern_size,
Jens Axboe4764aec2007-08-23 09:03:38 +0200371 char *buf, unsigned int len, unsigned int mod)
Shawn Lewisa944e332007-08-02 22:18:29 +0200372{
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++) {
Jens Axboe3f199b02007-08-09 10:16:31 +0200382 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);
Jens Axboed16d4e02007-09-06 16:16:44 +0200389 return EIO;
Jens Axboe3f199b02007-08-09 10:16:31 +0200390 }
Shawn Lewisa944e332007-08-02 22:18:29 +0200391 mod++;
392 if (mod == pattern_size)
393 mod = 0;
394 }
395
396 return 0;
397}
398
Jens Axboe36690c92007-03-26 10:23:34 +0200399int verify_io_u(struct thread_data *td, struct io_u *io_u)
Jens Axboee29d1b72006-10-18 15:43:15 +0200400{
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200401 struct verify_header *hdr;
Shawn Lewisa944e332007-08-02 22:18:29 +0200402 unsigned int hdr_size, hdr_inc, hdr_num = 0;
Jens Axboe95646102007-07-28 21:17:50 +0200403 void *p;
Jens Axboee29d1b72006-10-18 15:43:15 +0200404 int ret;
405
Shawn Lewis1dcc0492007-07-27 08:02:45 +0200406 if (td->o.verify == VERIFY_NULL || io_u->ddir != DDIR_READ)
Jens Axboe36690c92007-03-26 10:23:34 +0200407 return 0;
408
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200409 hdr_inc = io_u->buflen;
Jens Axboea59e1702007-07-30 08:53:27 +0200410 if (td->o.verify_interval)
411 hdr_inc = td->o.verify_interval;
Jens Axboee29d1b72006-10-18 15:43:15 +0200412
Jens Axboea12a3b42007-08-09 10:20:54 +0200413 ret = 0;
Jens Axboe3f199b02007-08-09 10:16:31 +0200414 for (p = io_u->buf; p < io_u->buf + io_u->buflen; p += hdr_inc, hdr_num++) {
Jens Axboea12a3b42007-08-09 10:20:54 +0200415 if (ret && td->o.verify_fatal) {
416 td->terminate = 1;
417 break;
418 }
Shawn Lewisa944e332007-08-02 22:18:29 +0200419 hdr_size = __hdr_size(td->o.verify);
Jens Axboea59e1702007-07-30 08:53:27 +0200420 if (td->o.verify_offset)
Shawn Lewisa944e332007-08-02 22:18:29 +0200421 memswp(p, p + td->o.verify_offset, hdr_size);
Jens Axboe95646102007-07-28 21:17:50 +0200422 hdr = p;
Jens Axboee29d1b72006-10-18 15:43:15 +0200423
Jens Axboe3f199b02007-08-09 10:16:31 +0200424 if (hdr->fio_magic != FIO_HDR_MAGIC) {
425 log_err("Bad verify header %x\n", hdr->fio_magic);
426 return EIO;
427 }
428
Shawn Lewise28218f2008-01-16 11:01:33 +0100429 if (td->o.verify_pattern_bytes) {
Jens Axboebd6f78b2008-02-01 20:27:52 +0100430 dprint(FD_VERIFY, "pattern verify io_u %p, len %u\n",
431 io_u, hdr->len);
Shawn Lewise28218f2008-01-16 11:01:33 +0100432 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
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200444 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;
Jens Axboecd14cc12007-07-30 10:59:33 +0200460 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;
Shawn Lewis7437ee82007-08-02 21:05:58 +0200466 case VERIFY_META:
467 ret = verify_io_u_meta(hdr, td, io_u, hdr_num);
468 break;
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200469 default:
470 log_err("Bad verify type %u\n", hdr->verify_type);
Jens Axboed16d4e02007-09-06 16:16:44 +0200471 ret = EINVAL;
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200472 }
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200473 }
Jens Axboea7dfe862007-03-12 10:05:08 +0100474
Jens Axboea12a3b42007-08-09 10:20:54 +0200475 return ret;
Jens Axboee29d1b72006-10-18 15:43:15 +0200476}
477
Shawn Lewis7437ee82007-08-02 21:05:58 +0200478static 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
Jens Axboecd14cc12007-07-30 10:59:33 +0200493static void fill_sha512(struct verify_header *hdr, void *p, unsigned int len)
494{
Jens Axboe546dfd92007-07-30 12:23:05 +0200495 struct vhdr_sha512 *vh = hdr_priv(hdr);
Jens Axboecd14cc12007-07-30 10:59:33 +0200496 struct sha512_ctx sha512_ctx = {
Jens Axboe546dfd92007-07-30 12:23:05 +0200497 .buf = vh->sha512,
Jens Axboecd14cc12007-07-30 10:59:33 +0200498 };
499
500 sha512_init(&sha512_ctx);
501 sha512_update(&sha512_ctx, p, len);
502}
503
504static void fill_sha256(struct verify_header *hdr, void *p, unsigned int len)
505{
Jens Axboe546dfd92007-07-30 12:23:05 +0200506 struct vhdr_sha256 *vh = hdr_priv(hdr);
Jens Axboecd14cc12007-07-30 10:59:33 +0200507 struct sha256_ctx sha256_ctx = {
Jens Axboe546dfd92007-07-30 12:23:05 +0200508 .buf = vh->sha256,
Jens Axboecd14cc12007-07-30 10:59:33 +0200509 };
510
511 sha256_init(&sha256_ctx);
512 sha256_update(&sha256_ctx, p, len);
513}
514
Jens Axboe1e154bd2007-07-27 09:52:40 +0200515static void fill_crc7(struct verify_header *hdr, void *p, unsigned int len)
516{
Jens Axboe546dfd92007-07-30 12:23:05 +0200517 struct vhdr_crc7 *vh = hdr_priv(hdr);
518
519 vh->crc7 = crc7(p, len);
Jens Axboe1e154bd2007-07-27 09:52:40 +0200520}
521
Jens Axboe969f7ed2007-07-27 09:07:17 +0200522static void fill_crc16(struct verify_header *hdr, void *p, unsigned int len)
523{
Jens Axboe546dfd92007-07-30 12:23:05 +0200524 struct vhdr_crc16 *vh = hdr_priv(hdr);
525
526 vh->crc16 = crc16(p, len);
Jens Axboe969f7ed2007-07-27 09:07:17 +0200527}
528
Jens Axboee29d1b72006-10-18 15:43:15 +0200529static void fill_crc32(struct verify_header *hdr, void *p, unsigned int len)
530{
Jens Axboe546dfd92007-07-30 12:23:05 +0200531 struct vhdr_crc32 *vh = hdr_priv(hdr);
532
533 vh->crc32 = crc32(p, len);
Jens Axboee29d1b72006-10-18 15:43:15 +0200534}
535
Jens Axboed77a7af2007-07-27 15:35:06 +0200536static void fill_crc64(struct verify_header *hdr, void *p, unsigned int len)
537{
Jens Axboe546dfd92007-07-30 12:23:05 +0200538 struct vhdr_crc64 *vh = hdr_priv(hdr);
539
540 vh->crc64 = crc64(p, len);
Jens Axboed77a7af2007-07-27 15:35:06 +0200541}
542
Jens Axboee29d1b72006-10-18 15:43:15 +0200543static void fill_md5(struct verify_header *hdr, void *p, unsigned int len)
544{
Jens Axboe546dfd92007-07-30 12:23:05 +0200545 struct vhdr_md5 *vh = hdr_priv(hdr);
Jens Axboe8c432322007-07-27 13:16:24 +0200546 struct md5_ctx md5_ctx = {
Jens Axboe546dfd92007-07-30 12:23:05 +0200547 .hash = (uint32_t *) vh->md5_digest,
Jens Axboe8c432322007-07-27 13:16:24 +0200548 };
Jens Axboee29d1b72006-10-18 15:43:15 +0200549
Jens Axboe61f821f2007-07-30 10:18:06 +0200550 md5_init(&md5_ctx);
Jens Axboee29d1b72006-10-18 15:43:15 +0200551 md5_update(&md5_ctx, p, len);
Jens Axboee29d1b72006-10-18 15:43:15 +0200552}
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 */
558void populate_verify_io_u(struct thread_data *td, struct io_u *io_u)
559{
Jens Axboebaefa9b2007-07-27 12:57:25 +0200560 struct verify_header *hdr;
Jens Axboe95646102007-07-28 21:17:50 +0200561 void *p = io_u->buf, *data;
Shawn Lewis7437ee82007-08-02 21:05:58 +0200562 unsigned int hdr_inc, data_len, header_num = 0;
Jens Axboee29d1b72006-10-18 15:43:15 +0200563
Jens Axboe9cc3d152007-03-26 10:32:30 +0200564 if (td->o.verify == VERIFY_NULL)
565 return;
566
Jens Axboe90059d62007-07-30 09:33:12 +0200567 fill_pattern(td, p, io_u->buflen);
Jens Axboebaefa9b2007-07-27 12:57:25 +0200568
Shawn Lewis546a9142007-07-28 21:11:37 +0200569 hdr_inc = io_u->buflen;
Jens Axboea59e1702007-07-30 08:53:27 +0200570 if (td->o.verify_interval)
571 hdr_inc = td->o.verify_interval;
Shawn Lewis546a9142007-07-28 21:11:37 +0200572
Jens Axboe95646102007-07-28 21:17:50 +0200573 for (;p < io_u->buf + io_u->buflen; p += hdr_inc) {
574 hdr = p;
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200575
576 hdr->fio_magic = FIO_HDR_MAGIC;
577 hdr->verify_type = td->o.verify;
Shawn Lewis546a9142007-07-28 21:11:37 +0200578 hdr->len = hdr_inc;
Jens Axboe87677832007-07-30 12:08:14 +0200579 data_len = hdr_inc - hdr_size(hdr);
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200580
Jens Axboe87677832007-07-30 12:08:14 +0200581 data = p + hdr_size(hdr);
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200582 switch (td->o.verify) {
583 case VERIFY_MD5:
Jens Axboebd6f78b2008-02-01 20:27:52 +0100584 dprint(FD_VERIFY, "fill md5 io_u %p, len %u\n",
585 io_u, hdr->len);
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200586 fill_md5(hdr, data, data_len);
587 break;
588 case VERIFY_CRC64:
Jens Axboebd6f78b2008-02-01 20:27:52 +0100589 dprint(FD_VERIFY, "fill crc64 io_u %p, len %u\n",
590 io_u, hdr->len);
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200591 fill_crc64(hdr, data, data_len);
592 break;
593 case VERIFY_CRC32:
Jens Axboebd6f78b2008-02-01 20:27:52 +0100594 dprint(FD_VERIFY, "fill crc32 io_u %p, len %u\n",
595 io_u, hdr->len);
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200596 fill_crc32(hdr, data, data_len);
597 break;
598 case VERIFY_CRC16:
Jens Axboebd6f78b2008-02-01 20:27:52 +0100599 dprint(FD_VERIFY, "fill crc16 io_u %p, len %u\n",
600 io_u, hdr->len);
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200601 fill_crc16(hdr, data, data_len);
602 break;
603 case VERIFY_CRC7:
Jens Axboebd6f78b2008-02-01 20:27:52 +0100604 dprint(FD_VERIFY, "fill crc7 io_u %p, len %u\n",
605 io_u, hdr->len);
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200606 fill_crc7(hdr, data, data_len);
607 break;
Jens Axboecd14cc12007-07-30 10:59:33 +0200608 case VERIFY_SHA256:
Jens Axboebd6f78b2008-02-01 20:27:52 +0100609 dprint(FD_VERIFY, "fill sha256 io_u %p, len %u\n",
610 io_u, hdr->len);
Jens Axboecd14cc12007-07-30 10:59:33 +0200611 fill_sha256(hdr, data, data_len);
612 break;
613 case VERIFY_SHA512:
Jens Axboebd6f78b2008-02-01 20:27:52 +0100614 dprint(FD_VERIFY, "fill sha512 io_u %p, len %u\n",
615 io_u, hdr->len);
Jens Axboecd14cc12007-07-30 10:59:33 +0200616 fill_sha512(hdr, data, data_len);
617 break;
Shawn Lewis7437ee82007-08-02 21:05:58 +0200618 case VERIFY_META:
Jens Axboebd6f78b2008-02-01 20:27:52 +0100619 dprint(FD_VERIFY, "fill meta io_u %p, len %u\n",
620 io_u, hdr->len);
Shawn Lewis7437ee82007-08-02 21:05:58 +0200621 fill_meta(hdr, td, io_u, header_num);
622 break;
Shawn Lewis3f9f4e22007-07-28 21:10:37 +0200623 default:
624 log_err("fio: bad verify type: %d\n", td->o.verify);
625 assert(0);
626 }
Jens Axboea59e1702007-07-30 08:53:27 +0200627 if (td->o.verify_offset)
Jens Axboe87677832007-07-30 12:08:14 +0200628 memswp(p, p + td->o.verify_offset, hdr_size(hdr));
Shawn Lewis7437ee82007-08-02 21:05:58 +0200629 header_num++;
Jens Axboee29d1b72006-10-18 15:43:15 +0200630 }
Jens Axboee29d1b72006-10-18 15:43:15 +0200631}
632
633int get_next_verify(struct thread_data *td, struct io_u *io_u)
634{
Jens Axboe8de8f042007-03-27 10:36:12 +0200635 struct io_piece *ipo = NULL;
Jens Axboee29d1b72006-10-18 15:43:15 +0200636
Jens Axboed2d7fa52007-02-19 13:21:35 +0100637 /*
638 * this io_u is from a requeue, we already filled the offsets
639 */
640 if (io_u->file)
641 return 0;
642
Jens Axboe8de8f042007-03-27 10:36:12 +0200643 if (!RB_EMPTY_ROOT(&td->io_hist_tree)) {
644 struct rb_node *n = rb_first(&td->io_hist_tree);
645
Jens Axboe4b878982007-03-26 09:32:22 +0200646 ipo = rb_entry(n, struct io_piece, rb_node);
Jens Axboe4b878982007-03-26 09:32:22 +0200647 rb_erase(n, &td->io_hist_tree);
Jens Axboe8de8f042007-03-27 10:36:12 +0200648 } 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 }
Jens Axboee29d1b72006-10-18 15:43:15 +0200652
Jens Axboe8de8f042007-03-27 10:36:12 +0200653 if (ipo) {
Jens Axboee29d1b72006-10-18 15:43:15 +0200654 io_u->offset = ipo->offset;
655 io_u->buflen = ipo->len;
Jens Axboe36167d82007-02-18 05:41:31 +0100656 io_u->file = ipo->file;
Jens Axboe97af62c2007-05-22 11:12:13 +0200657
658 if ((io_u->file->flags & FIO_FILE_OPEN) == 0) {
659 int r = td_io_open_file(td, io_u->file);
660
Jens Axboebd6f78b2008-02-01 20:27:52 +0100661 if (r) {
662 dprint(FD_VERIFY, "failed file %s open\n",
663 io_u->file->file_name);
Jens Axboe97af62c2007-05-22 11:12:13 +0200664 return 1;
Jens Axboebd6f78b2008-02-01 20:27:52 +0100665 }
Jens Axboe97af62c2007-05-22 11:12:13 +0200666 }
667
668 get_file(ipo->file);
669 assert(io_u->file->flags & FIO_FILE_OPEN);
Jens Axboee29d1b72006-10-18 15:43:15 +0200670 io_u->ddir = DDIR_READ;
Jens Axboe36167d82007-02-18 05:41:31 +0100671 io_u->xfer_buf = io_u->buf;
672 io_u->xfer_buflen = io_u->buflen;
Jens Axboee29d1b72006-10-18 15:43:15 +0200673 free(ipo);
Jens Axboebd6f78b2008-02-01 20:27:52 +0100674 dprint(FD_VERIFY, "get_next_verify: ret io_u %p\n", io_u);
Jens Axboee29d1b72006-10-18 15:43:15 +0200675 return 0;
676 }
677
Jens Axboebd6f78b2008-02-01 20:27:52 +0100678 dprint(FD_VERIFY, "get_next_verify: empty\n");
Jens Axboee29d1b72006-10-18 15:43:15 +0200679 return 1;
680}