static int verify_io_u_md5(struct verify_header *hdr, struct vcont *vc) { void *p = io_u_verify_off(hdr, vc); struct vhdr_md5 *vh = hdr_priv(hdr); uint32_t hash[MD5_HASH_WORDS]; struct fio_md5_ctx md5_ctx = { .hash = hash, }; dprint(FD_VERIFY, "md5 verify io_u %p, len %u\n", vc->io_u, hdr->len); fio_md5_init(&md5_ctx); fio_md5_update(&md5_ctx, p, hdr->len - hdr_size(vc->td, hdr)); fio_md5_final(&md5_ctx); if (!memcmp(vh->md5_digest, md5_ctx.hash, sizeof(hash))) return 0; vc->name = "md5"; vc->good_crc = vh->md5_digest; vc->bad_crc = md5_ctx.hash; vc->crc_len = sizeof(hash); log_verify_failure(hdr, vc); return EILSEQ; }
static int verify_io_u_sha1(struct verify_header *hdr, struct vcont *vc) { void *p = io_u_verify_off(hdr, vc); struct vhdr_sha1 *vh = hdr_priv(hdr); uint32_t sha1[5]; struct fio_sha1_ctx sha1_ctx = { .H = sha1, }; dprint(FD_VERIFY, "sha1 verify io_u %p, len %u\n", vc->io_u, hdr->len); fio_sha1_init(&sha1_ctx); fio_sha1_update(&sha1_ctx, p, hdr->len - hdr_size(vc->td, hdr)); fio_sha1_final(&sha1_ctx); if (!memcmp(vh->sha1, sha1_ctx.H, sizeof(sha1))) return 0; vc->name = "sha1"; vc->good_crc = vh->sha1; vc->bad_crc = sha1_ctx.H; vc->crc_len = sizeof(vh->sha1); log_verify_failure(hdr, vc); return EILSEQ; }
static int verify_io_u_sha256(struct verify_header *hdr, struct vcont *vc) { void *p = io_u_verify_off(hdr, vc); struct vhdr_sha256 *vh = hdr_priv(hdr); uint8_t sha256[64]; struct fio_sha256_ctx sha256_ctx = { .buf = sha256, }; dprint(FD_VERIFY, "sha256 verify io_u %p, len %u\n", vc->io_u, hdr->len); fio_sha256_init(&sha256_ctx); fio_sha256_update(&sha256_ctx, p, hdr->len - hdr_size(vc->td, hdr)); fio_sha256_final(&sha256_ctx); if (!memcmp(vh->sha256, sha256_ctx.buf, sizeof(sha256))) return 0; vc->name = "sha256"; vc->good_crc = vh->sha256; vc->bad_crc = sha256_ctx.buf; vc->crc_len = sizeof(vh->sha256); log_verify_failure(hdr, vc); return EILSEQ; }
static int verify_io_u_meta(struct verify_header *hdr, struct vcont *vc) { struct thread_data *td = vc->td; struct vhdr_meta *vh = hdr_priv(hdr); struct io_u *io_u = vc->io_u; int ret = EILSEQ; dprint(FD_VERIFY, "meta verify io_u %p, len %u\n", io_u, hdr->len); if (vh->offset == io_u->offset + vc->hdr_num * td->o.verify_interval) ret = 0; if (td->o.verify_pattern_bytes) ret |= verify_io_u_pattern(hdr, vc); /* * For read-only workloads, the program cannot be certain of the * last numberio written to a block. Checking of numberio will be done * only for workloads that write data. * For verify_only, numberio will be checked in the last iteration when * the correct state of numberio, that would have been written to each * block in a previous run of fio, has been reached. */ if (td_write(td) || td_rw(td)) if (!td->o.verify_only || td->o.loops == 0) if (vh->numberio != io_u->numberio) ret = EILSEQ; if (!ret) return 0; vc->name = "meta"; log_verify_failure(hdr, vc); return ret; }
static int verify_io_u_crc32c(struct verify_header *hdr, struct vcont *vc) { void *p = io_u_verify_off(hdr, vc); struct vhdr_crc32 *vh = hdr_priv(hdr); uint32_t c; dprint(FD_VERIFY, "crc32c verify io_u %p, len %u\n", vc->io_u, hdr->len); c = fio_crc32c(p, hdr->len - hdr_size(vc->td, hdr)); if (c == vh->crc32) return 0; vc->name = "crc32c"; vc->good_crc = &vh->crc32; vc->bad_crc = &c; vc->crc_len = 4; log_verify_failure(hdr, vc); return EILSEQ; }
static int verify_io_u_crc64(struct verify_header *hdr, struct vcont *vc) { void *p = io_u_verify_off(hdr, vc); struct vhdr_crc64 *vh = hdr_priv(hdr); unsigned long long c; dprint(FD_VERIFY, "crc64 verify io_u %p, len %u\n", vc->io_u, hdr->len); c = fio_crc64(p, hdr->len - hdr_size(vc->td, hdr)); if (c == vh->crc64) return 0; vc->name = "crc64"; vc->good_crc = &vh->crc64; vc->bad_crc = &c; vc->crc_len = 8; log_verify_failure(hdr, vc); return EILSEQ; }
static int verify_io_u_meta(struct verify_header *hdr, struct vcont *vc) { struct thread_data *td = vc->td; struct vhdr_meta *vh = hdr_priv(hdr); struct io_u *io_u = vc->io_u; int ret = EILSEQ; dprint(FD_VERIFY, "meta verify io_u %p, len %u\n", io_u, hdr->len); if (vh->offset == io_u->offset + vc->hdr_num * td->o.verify_interval) ret = 0; if (td->o.verify_pattern_bytes) ret |= verify_io_u_pattern(hdr, vc); if (!ret) return 0; vc->name = "meta"; log_verify_failure(hdr, vc); return ret; }
static int verify_io_u_xxhash(struct verify_header *hdr, struct vcont *vc) { void *p = io_u_verify_off(hdr, vc); struct vhdr_xxhash *vh = hdr_priv(hdr); uint32_t hash; void *state; dprint(FD_VERIFY, "xxhash verify io_u %p, len %u\n", vc->io_u, hdr->len); state = XXH32_init(1); XXH32_update(state, p, hdr->len - hdr_size(vc->td, hdr)); hash = XXH32_digest(state); if (vh->hash == hash) return 0; vc->name = "xxhash"; vc->good_crc = &vh->hash; vc->bad_crc = &hash; vc->crc_len = sizeof(hash); log_verify_failure(hdr, vc); return EILSEQ; }