X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=verify.c;h=c894b600525c5969d5ddefb1d9eafe51c6a7ece9;hp=fc154ab8cbde68854fb584e36fdf71e2756c4a9c;hb=3ae0637148904b5c68cb95e749460e37e3502a9c;hpb=b36e298b5bdfc31ffc9a4c14e94a9c5c748888b0 diff --git a/verify.c b/verify.c index fc154ab8..c894b600 100644 --- a/verify.c +++ b/verify.c @@ -19,6 +19,7 @@ #include "crc/crc7.h" #include "crc/sha256.h" #include "crc/sha512.h" +#include "crc/sha1.h" static void fill_random_bytes(struct thread_data *td, void *p, unsigned int len) { @@ -52,38 +53,21 @@ static void fill_pattern(struct thread_data *td, void *p, unsigned int len) break; case 1: dprint(FD_VERIFY, "fill verify pattern b=0 len=%u\n", len); - memset(p, td->o.verify_pattern, len); + memset(p, td->o.verify_pattern[0], len); break; - case 2: - case 3: - case 4: { - unsigned int pattern = td->o.verify_pattern; - unsigned int i = 0; - unsigned char c1, c2, c3, c4; + default: { + unsigned int i = 0, size = 0; unsigned char *b = p; dprint(FD_VERIFY, "fill verify pattern b=%d len=%u\n", td->o.verify_pattern_bytes, len); - c1 = pattern & 0xff; - pattern >>= 8; - c2 = pattern & 0xff; - pattern >>= 8; - c3 = pattern & 0xff; - pattern >>= 8; - c4 = pattern & 0xff; - while (i < len) { - b[i++] = c1; - if (i == len) - break; - b[i++] = c2; - if (td->o.verify_pattern_bytes == 2 || i == len) - continue; - b[i++] = c3; - if (td->o.verify_pattern_bytes == 3 || i == len) - continue; - b[i++] = c4; + size = td->o.verify_pattern_bytes; + if (size > (len - i)) + size = len - i; + memcpy(b+i, td->o.verify_pattern, size); + i += size; } break; } @@ -149,6 +133,9 @@ static inline unsigned int __hdr_size(int verify_type) case VERIFY_META: len = sizeof(struct vhdr_meta); break; + case VERIFY_SHA1: + len = sizeof(struct vhdr_sha1); + break; default: log_err("fio: unknown verify header!\n"); assert(0); @@ -225,7 +212,7 @@ static int verify_io_u_sha256(struct verify_header *hdr, struct io_u *io_u, { void *p = io_u_verify_off(hdr, io_u, header_num); struct vhdr_sha256 *vh = hdr_priv(hdr); - uint8_t sha256[128]; + uint8_t sha256[64]; struct sha256_ctx sha256_ctx = { .buf = sha256, }; @@ -246,6 +233,32 @@ static int verify_io_u_sha256(struct verify_header *hdr, struct io_u *io_u, return 0; } +static int verify_io_u_sha1(struct verify_header *hdr, struct io_u *io_u, + unsigned int header_num) +{ + void *p = io_u_verify_off(hdr, io_u, header_num); + struct vhdr_sha1 *vh = hdr_priv(hdr); + uint32_t sha1[5]; + struct sha1_ctx sha1_ctx = { + .H = sha1, + }; + + dprint(FD_VERIFY, "sha1 verify io_u %p, len %u\n", io_u, hdr->len); + + sha1_init(&sha1_ctx); + sha1_update(&sha1_ctx, p, hdr->len - hdr_size(hdr)); + + if (memcmp(vh->sha1, sha1_ctx.H, sizeof(sha1))) { + log_err("sha1: verify failed at %llu/%u\n", + io_u->offset + header_num * hdr->len, hdr->len); + hexdump(vh->sha1, sizeof(vh->sha1)); + hexdump(sha1_ctx.H, sizeof(sha1)); + return EILSEQ; + } + + return 0; +} + static int verify_io_u_crc7(struct verify_header *hdr, struct io_u *io_u, unsigned char header_num) { @@ -390,24 +403,18 @@ static unsigned int hweight8(unsigned int w) return (res + (res >> 4)) & 0x0F; } -int verify_io_u_pattern(unsigned long pattern, unsigned long pattern_size, +int verify_io_u_pattern(char *pattern, unsigned long pattern_size, char *buf, unsigned int len, unsigned int mod) { unsigned int i; - char split_pattern[4]; - - for (i = 0; i < 4; i++) { - split_pattern[i] = pattern & 0xff; - pattern >>= 8; - } for (i = 0; i < len; i++) { - if (buf[i] != split_pattern[mod]) { + if (buf[i] != pattern[mod]) { unsigned int bits; - bits = hweight8(buf[i] ^ split_pattern[mod]); + bits = hweight8(buf[i] ^ pattern[mod]); log_err("fio: got pattern %x, wanted %x. Bad bits %d\n", - buf[i], split_pattern[mod], bits); + buf[i], pattern[mod], bits); log_err("fio: bad pattern block offset %u\n", i); return EILSEQ; } @@ -430,12 +437,17 @@ int verify_io_u_async(struct thread_data *td, struct io_u *io_u) io_u->file = NULL; pthread_mutex_lock(&td->io_u_lock); + + if (io_u->flags & IO_U_F_IN_CUR_DEPTH) { + td->cur_depth--; + io_u->flags &= ~IO_U_F_IN_CUR_DEPTH; + } flist_del(&io_u->list); flist_add_tail(&io_u->list, &td->verify_list); + io_u->flags |= IO_U_F_FREE_DEF; pthread_mutex_unlock(&td->io_u_lock); pthread_cond_signal(&td->verify_cond); - io_u->flags |= IO_U_F_FREE_DEF; return 0; } @@ -466,7 +478,9 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u) hdr = p; if (hdr->fio_magic != FIO_HDR_MAGIC) { - log_err("Bad verify header %x\n", hdr->fio_magic); + log_err("Bad verify header %x at %llu\n", + hdr->fio_magic, + io_u->offset + hdr_num * hdr->len); return EILSEQ; } @@ -474,10 +488,16 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u) dprint(FD_VERIFY, "pattern verify io_u %p, len %u\n", io_u, hdr->len); ret = verify_io_u_pattern(td->o.verify_pattern, - td->o.verify_pattern_bytes, - p + hdr_size, - hdr_inc - hdr_size, - hdr_size % 4); + td->o.verify_pattern_bytes, + p + hdr_size, + hdr_inc - hdr_size, + hdr_size % td->o.verify_pattern_bytes); + /* + * Also verify the meta data, if applicable + */ + if (hdr->verify_type == VERIFY_META) + ret |= verify_io_u_meta(hdr, td, io_u, hdr_num); + if (ret) log_err("fio: verify failed at %llu/%u\n", io_u->offset + hdr_num * hdr->len, @@ -514,6 +534,9 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u) case VERIFY_META: ret = verify_io_u_meta(hdr, td, io_u, hdr_num); break; + case VERIFY_SHA1: + ret = verify_io_u_sha1(hdr, io_u, hdr_num); + break; default: log_err("Bad verify type %u\n", hdr->verify_type); ret = EINVAL; @@ -560,6 +583,17 @@ static void fill_sha256(struct verify_header *hdr, void *p, unsigned int len) sha256_update(&sha256_ctx, p, len); } +static void fill_sha1(struct verify_header *hdr, void *p, unsigned int len) +{ + struct vhdr_sha1 *vh = hdr_priv(hdr); + struct sha1_ctx sha1_ctx = { + .H = vh->sha1, + }; + + sha1_init(&sha1_ctx); + sha1_update(&sha1_ctx, p, len); +} + static void fill_crc7(struct verify_header *hdr, void *p, unsigned int len) { struct vhdr_crc7 *vh = hdr_priv(hdr); @@ -684,6 +718,11 @@ void populate_verify_io_u(struct thread_data *td, struct io_u *io_u) io_u, hdr->len); fill_meta(hdr, td, io_u, header_num); break; + case VERIFY_SHA1: + dprint(FD_VERIFY, "fill sha1 io_u %p, len %u\n", + io_u, hdr->len); + fill_sha1(hdr, data, data_len); + break; default: log_err("fio: bad verify type: %d\n", td->o.verify); assert(0); @@ -836,6 +875,7 @@ int verify_async_init(struct thread_data *td) } if (i != td->o.verify_async) { + log_err("fio: only %d verify threads started, exiting\n", i); td->verify_thread_exit = 1; write_barrier(); pthread_cond_broadcast(&td->verify_cond);