X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=verify.c;h=193e171871928265dad467d6570800dc788cd669;hb=da7d79b07a41d0b3505feecda2561811217ea8e7;hp=3f27e5ac0775f8e645b7e85574371e013e90595f;hpb=9fd189697dbf9fb7878093be5e41f25b7f932c2d;p=fio.git diff --git a/verify.c b/verify.c index 3f27e5ac..193e1718 100644 --- a/verify.c +++ b/verify.c @@ -5,8 +5,11 @@ #include #include #include +#include #include "fio.h" +#include "verify.h" +#include "smalloc.h" #include "crc/md5.h" #include "crc/crc64.h" @@ -16,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) { @@ -146,6 +150,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); @@ -243,6 +250,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) { @@ -416,6 +449,26 @@ int verify_io_u_pattern(unsigned long pattern, unsigned long pattern_size, return 0; } +/* + * Push IO verification to a separate thread + */ +int verify_io_u_async(struct thread_data *td, struct io_u *io_u) +{ + if (io_u->file) + put_file_log(td, io_u->file); + + io_u->file = NULL; + + pthread_mutex_lock(&td->io_u_lock); + flist_del(&io_u->list); + flist_add_tail(&io_u->list, &td->verify_list); + pthread_mutex_unlock(&td->io_u_lock); + + pthread_cond_signal(&td->verify_cond); + io_u->flags |= IO_U_F_FREE_DEF; + return 0; +} + int verify_io_u(struct thread_data *td, struct io_u *io_u) { struct verify_header *hdr; @@ -455,6 +508,12 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u) p + hdr_size, hdr_inc - hdr_size, hdr_size % 4); + /* + * 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, @@ -491,6 +550,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; @@ -537,6 +599,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); @@ -661,6 +734,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); @@ -696,7 +774,7 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u) io_u->buflen = ipo->len; io_u->file = ipo->file; - if ((io_u->file->flags & FIO_FILE_OPEN) == 0) { + if (!fio_file_open(io_u->file)) { int r = td_io_open_file(td, io_u->file); if (r) { @@ -707,7 +785,7 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u) } get_file(ipo->file); - assert(io_u->file->flags & FIO_FILE_OPEN); + assert(fio_file_open(io_u->file)); io_u->ddir = DDIR_READ; io_u->xfer_buf = io_u->buf; io_u->xfer_buflen = io_u->buflen; @@ -719,3 +797,122 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u) dprint(FD_VERIFY, "get_next_verify: empty\n"); return 1; } + +static void *verify_async_thread(void *data) +{ + struct thread_data *td = data; + struct io_u *io_u; + int ret = 0; + + if (td->o.verify_cpumask_set && + fio_setaffinity(td->pid, td->o.verify_cpumask)) { + log_err("fio: failed setting verify thread affinity\n"); + goto done; + } + + do { + FLIST_HEAD(list); + + read_barrier(); + if (td->verify_thread_exit) + break; + + pthread_mutex_lock(&td->io_u_lock); + + while (flist_empty(&td->verify_list) && + !td->verify_thread_exit) { + ret = pthread_cond_wait(&td->verify_cond, + &td->io_u_lock); + if (ret) { + pthread_mutex_unlock(&td->io_u_lock); + break; + } + } + + flist_splice_init(&td->verify_list, &list); + pthread_mutex_unlock(&td->io_u_lock); + + if (flist_empty(&list)) + continue; + + while (!flist_empty(&list)) { + io_u = flist_entry(list.next, struct io_u, list); + flist_del_init(&io_u->list); + + ret = verify_io_u(td, io_u); + put_io_u(td, io_u); + if (!ret) + continue; + if (td->o.continue_on_error && + td_non_fatal_error(ret)) { + update_error_count(td, ret); + td_clear_error(td); + ret = 0; + } + } + } while (!ret); + + if (ret) { + td_verror(td, ret, "async_verify"); + td->terminate = 1; + } + +done: + pthread_mutex_lock(&td->io_u_lock); + td->nr_verify_threads--; + pthread_mutex_unlock(&td->io_u_lock); + + pthread_cond_signal(&td->free_cond); + return NULL; +} + +int verify_async_init(struct thread_data *td) +{ + int i, ret; + + td->verify_thread_exit = 0; + + td->verify_threads = malloc(sizeof(pthread_t) * td->o.verify_async); + for (i = 0; i < td->o.verify_async; i++) { + ret = pthread_create(&td->verify_threads[i], NULL, + verify_async_thread, td); + if (ret) { + log_err("fio: async verify creation failed: %s\n", + strerror(ret)); + break; + } + ret = pthread_detach(td->verify_threads[i]); + if (ret) { + log_err("fio: async verify thread detach failed: %s\n", + strerror(ret)); + break; + } + td->nr_verify_threads++; + } + + 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); + return 1; + } + + return 0; +} + +void verify_async_exit(struct thread_data *td) +{ + td->verify_thread_exit = 1; + write_barrier(); + pthread_cond_broadcast(&td->verify_cond); + + pthread_mutex_lock(&td->io_u_lock); + + while (td->nr_verify_threads) + pthread_cond_wait(&td->free_cond, &td->io_u_lock); + + pthread_mutex_unlock(&td->io_u_lock); + free(td->verify_threads); + td->verify_threads = NULL; +}