Fix race condition when using asynch verify

[fio.git] / verify.c

diff --git a/verify.c b/verify.c
index 10bad7e2bab5f65c8b9168333a5f2567e40d19e1..7d675e46de6b110c25b0145bd00b1453eba60e2f 100644 (file)
--- 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);
@@ -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,6 +437,11 @@ 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);
        pthread_mutex_unlock(&td->io_u_lock);
@@ -474,10 +486,10 @@ 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
                         */
@@ -520,6 +532,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;
@@ -566,6 +581,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);
@@ -690,6 +716,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);