Streamline pattern/meta verifies instead of special casing them

Signed-off-by: Jens Axboe <jaxboe@fusionio.com>

diff --git a/options.c b/options.c
index 37e68d264d928bebdf7ae6b804f14b15549da3cb..163e50899e4122d322f4a293b496b95b67d11811 100644 (file)
--- a/options.c
+++ b/options.c
@@ -675,6 +675,11 @@ static int str_verify_pattern_cb(void *data, const char *input)
                }
        }
        td->o.verify_pattern_bytes = i;
                }
        }
        td->o.verify_pattern_bytes = i;

+       /*
+        * VERIFY_META could already be set
+        */
+       if (td->o.verify == VERIFY_NONE)
+               td->o.verify = VERIFY_PATTERN;

        return 0;
 }
 
        return 0;
 }
 

diff --git a/verify.c b/verify.c
index 66b3ef0d36583d1f7a045821b139b3961d5d03f5..3eac9cab4ebaa975c7e20f4e57aade6bbc1738f9 100644 (file)
--- a/verify.c
+++ b/verify.c
@@ -179,6 +179,9 @@ static inline unsigned int __hdr_size(int verify_type)
        case VERIFY_SHA1:
                len = sizeof(struct vhdr_sha1);
                break;
        case VERIFY_SHA1:
                len = sizeof(struct vhdr_sha1);
                break;

+       case VERIFY_PATTERN:
+               len = 0;
+               break;

        default:
                log_err("fio: unknown verify header!\n");
                assert(0);
        default:
                log_err("fio: unknown verify header!\n");
                assert(0);


@@ -317,20 +320,67 @@ static inline void *io_u_verify_off(struct verify_header *hdr, struct vcont *vc)
        return vc->io_u->buf + vc->hdr_num * hdr->len + hdr_size(hdr);
 }
 
        return vc->io_u->buf + vc->hdr_num * hdr->len + hdr_size(hdr);
 }
 

-static int verify_io_u_meta(struct verify_header *hdr, struct thread_data *td,
-                           struct vcont *vc)
+static unsigned int hweight8(unsigned int w)
+{
+       unsigned int res = w - ((w >> 1) & 0x55);
+
+       res = (res & 0x33) + ((res >> 2) & 0x33);
+       return (res + (res >> 4)) & 0x0F;
+}
+
+static int verify_io_u_pattern(struct verify_header *hdr, struct vcont *vc)
+{
+       struct thread_data *td = vc->td;
+       struct io_u *io_u = vc->io_u;
+       char *buf, *pattern;
+       unsigned int hdr_size = __hdr_size(td->o.verify);
+       unsigned int len, mod, i;
+
+       pattern = td->o.verify_pattern;
+       buf = (void *) hdr + hdr_size;
+       len = get_hdr_inc(td, io_u) - hdr_size;
+       mod = hdr_size % td->o.verify_pattern_bytes;
+
+       for (i = 0; i < len; i++) {
+               if (buf[i] != pattern[mod]) {
+                       unsigned int bits;
+
+                       bits = hweight8(buf[i] ^ pattern[mod]);
+                       log_err("fio: got pattern %x, wanted %x. Bad bits %d\n",
+                               buf[i], pattern[mod], bits);
+                       log_err("fio: bad pattern block offset %u\n", i);
+                       dump_verify_buffers(hdr, vc);
+                       return EILSEQ;
+               }
+               mod++;
+               if (mod == td->o.verify_pattern_bytes)
+                       mod = 0;
+       }
+
+       return 0;
+}
+
+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;
        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)
 
        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 0;
 
        vc->name = "meta";
        log_verify_failure(hdr, vc);

-       return EILSEQ;
+       return ret;

 }
 
 static int verify_io_u_sha512(struct verify_header *hdr, struct vcont *vc)
 }
 
 static int verify_io_u_sha512(struct verify_header *hdr, struct vcont *vc)


@@ -541,46 +591,6 @@ static int verify_io_u_md5(struct verify_header *hdr, struct vcont *vc)
        return EILSEQ;
 }
 
        return EILSEQ;
 }
 

-static unsigned int hweight8(unsigned int w)
-{
-       unsigned int res = w - ((w >> 1) & 0x55);
-
-       res = (res & 0x33) + ((res >> 2) & 0x33);
-       return (res + (res >> 4)) & 0x0F;
-}
-
-int verify_io_u_pattern(struct verify_header *hdr, struct vcont *vc)
-{
-       struct thread_data *td = vc->td;
-       struct io_u *io_u = vc->io_u;
-       char *buf, *pattern;
-       unsigned int hdr_size = __hdr_size(td->o.verify);
-       unsigned int len, mod, i;
-
-       pattern = td->o.verify_pattern;
-       buf = (void *) hdr + hdr_size;
-       len = get_hdr_inc(td, io_u) - hdr_size;
-       mod = hdr_size % td->o.verify_pattern_bytes;
-
-       for (i = 0; i < len; i++) {
-               if (buf[i] != pattern[mod]) {
-                       unsigned int bits;
-
-                       bits = hweight8(buf[i] ^ pattern[mod]);
-                       log_err("fio: got pattern %x, wanted %x. Bad bits %d\n",
-                               buf[i], pattern[mod], bits);
-                       log_err("fio: bad pattern block offset %u\n", i);
-                       dump_verify_buffers(hdr, vc);
-                       return EILSEQ;
-               }
-               mod++;
-               if (mod == td->o.verify_pattern_bytes)
-                       mod = 0;
-       }
-
-       return 0;
-}
-

 /*
  * Push IO verification to a separate thread
  */
 /*
  * Push IO verification to a separate thread
  */


@@ -681,25 +691,6 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u)
                        return EILSEQ;
                }
 
                        return EILSEQ;
                }
 

-               if (td->o.verify_pattern_bytes) {
-                       dprint(FD_VERIFY, "pattern verify io_u %p, len %u\n",
-                                                               io_u, hdr->len);
-                       ret = verify_io_u_pattern(hdr, &vc);
-                       if (ret) {
-                               log_err("pattern: verify failed at file %s offset %llu, length %u\n",
-                                       io_u->file->file_name,
-                                       io_u->offset + hdr_num * hdr->len,
-                                       hdr->len);
-                       }
-
-                       /*
-                        * Also verify the meta data, if applicable
-                        */
-                       if (hdr->verify_type == VERIFY_META)
-                               ret |= verify_io_u_meta(hdr, td, &vc);
-                       continue;
-               }
-

                switch (hdr->verify_type) {
                case VERIFY_MD5:
                        ret = verify_io_u_md5(hdr, &vc);
                switch (hdr->verify_type) {
                case VERIFY_MD5:
                        ret = verify_io_u_md5(hdr, &vc);


@@ -727,11 +718,14 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u)
                        ret = verify_io_u_sha512(hdr, &vc);
                        break;
                case VERIFY_META:
                        ret = verify_io_u_sha512(hdr, &vc);
                        break;
                case VERIFY_META:

-                       ret = verify_io_u_meta(hdr, td, &vc);
+                       ret = verify_io_u_meta(hdr, &vc);

                        break;
                case VERIFY_SHA1:
                        ret = verify_io_u_sha1(hdr, &vc);
                        break;
                        break;
                case VERIFY_SHA1:
                        ret = verify_io_u_sha1(hdr, &vc);
                        break;

+               case VERIFY_PATTERN:
+                       ret = verify_io_u_pattern(hdr, &vc);
+                       break;

                default:
                        log_err("Bad verify type %u\n", hdr->verify_type);
                        ret = EINVAL;
                default:
                        log_err("Bad verify type %u\n", hdr->verify_type);
                        ret = EINVAL;


@@ -910,6 +904,9 @@ static void populate_hdr(struct thread_data *td, struct io_u *io_u,
                                                io_u, hdr->len);
                fill_sha1(hdr, data, data_len);
                break;
                                                io_u, hdr->len);
                fill_sha1(hdr, data, data_len);
                break;

+       case VERIFY_PATTERN:
+               /* nothing to do here */
+               break;

        default:
                log_err("fio: bad verify type: %d\n", td->o.verify);
                assert(0);
        default:
                log_err("fio: bad verify type: %d\n", td->o.verify);
                assert(0);

diff --git a/verify.h b/verify.h
index d5a906e4bee4aaeaae57cd2eeb3f1c16e2836ae9..49ce417cff8c200bbc252b266867db857781d471 100644 (file)
--- a/verify.h
+++ b/verify.h
@@ -18,6 +18,7 @@ enum {
        VERIFY_SHA512,                  /* sha512 sum data blocks */
        VERIFY_META,                    /* block_num, timestamp etc. */
        VERIFY_SHA1,                    /* sha1 sum data blocks */
        VERIFY_SHA512,                  /* sha512 sum data blocks */
        VERIFY_META,                    /* block_num, timestamp etc. */
        VERIFY_SHA1,                    /* sha1 sum data blocks */

+       VERIFY_PATTERN,                 /* verify specific patterns */

        VERIFY_NULL,                    /* pretend to verify */
 };
 
        VERIFY_NULL,                    /* pretend to verify */
 };