verify: add support for the sha3 variants

Signed-off-by: Jens Axboe <axboe@fb.com>

diff --git a/HOWTO b/HOWTO
index a72d868617e0b9ef9f7b56017e521adc4a0ae875..15ed42549580a659c82cd5febb7e4be6a441addc 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -2355,6 +2355,18 @@ Verification
                **sha1**
                        Use optimized sha1 as the checksum function.
 
                **sha1**
                        Use optimized sha1 as the checksum function.
 

+               **sha3-224**
+                       Use optimized sha3-224 as the checksum function.
+
+               **sha3-256**
+                       Use optimized sha3-256 as the checksum function.
+
+               **sha3-384**
+                       Use optimized sha3-384 as the checksum function.
+
+               **sha3-512**
+                       Use optimized sha3-512 as the checksum function.
+

                **meta**
                        This option is deprecated, since now meta information is included in
                        generic verification header and meta verification happens by
                **meta**
                        This option is deprecated, since now meta information is included in
                        generic verification header and meta verification happens by

diff --git a/fio.1 b/fio.1
index 56f2d11078b583aa4c6844d7fd39c4bedc35dc33..cc68dee34f8640dd546eaa45868e86ee572bcf45 100644 (file)
--- a/fio.1
+++ b/fio.1
@@ -1414,7 +1414,7 @@ option.  The allowed values are:
 .RS
 .RS
 .TP
 .RS
 .RS
 .TP

-.B md5 crc16 crc32 crc32c crc32c-intel crc64 crc7 sha256 sha512 sha1 xxhash
+.B md5 crc16 crc32 crc32c crc32c-intel crc64 crc7 sha256 sha512 sha1 sha3-224 sha3-256 sha3-384 sha3-512 xxhash

 Store appropriate checksum in the header of each block. crc32c-intel is
 hardware accelerated SSE4.2 driven, falls back to regular crc32c if
 not supported by the system.
 Store appropriate checksum in the header of each block. crc32c-intel is
 hardware accelerated SSE4.2 driven, falls back to regular crc32c if
 not supported by the system.

diff --git a/options.c b/options.c
index a543e5a3107c382403959d1cd2794fb156f83b4e..dcf0eeabba188c718170554e156e774d5d54250d 100644 (file)
--- a/options.c
+++ b/options.c
@@ -2674,6 +2674,22 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
                            .oval = VERIFY_SHA512,
                            .help = "Use sha512 checksums for verification",
                          },
                            .oval = VERIFY_SHA512,
                            .help = "Use sha512 checksums for verification",
                          },

+                         { .ival = "sha3-224",
+                           .oval = VERIFY_SHA3_224,
+                           .help = "Use sha3-224 checksums for verification",
+                         },
+                         { .ival = "sha3-256",
+                           .oval = VERIFY_SHA3_256,
+                           .help = "Use sha3-256 checksums for verification",
+                         },
+                         { .ival = "sha3-384",
+                           .oval = VERIFY_SHA3_384,
+                           .help = "Use sha3-384 checksums for verification",
+                         },
+                         { .ival = "sha3-512",
+                           .oval = VERIFY_SHA3_512,
+                           .help = "Use sha3-512 checksums for verification",
+                         },

                          { .ival = "xxhash",
                            .oval = VERIFY_XXHASH,
                            .help = "Use xxhash checksums for verification",
                          { .ival = "xxhash",
                            .oval = VERIFY_XXHASH,
                            .help = "Use xxhash checksums for verification",

diff --git a/verify.c b/verify.c
index 5c7e43d05b31ae519d841372c25c660895e6f376..f567ec1e67d6946158b95c7b6b0bc910d5f134c5 100644 (file)
--- a/verify.c
+++ b/verify.c
@@ -25,6 +25,7 @@
 #include "crc/sha512.h"
 #include "crc/sha1.h"
 #include "crc/xxhash.h"
 #include "crc/sha512.h"
 #include "crc/sha1.h"
 #include "crc/xxhash.h"

+#include "crc/sha3.h"

 
 static void populate_hdr(struct thread_data *td, struct io_u *io_u,
                         struct verify_header *hdr, unsigned int header_num,
 
 static void populate_hdr(struct thread_data *td, struct io_u *io_u,
                         struct verify_header *hdr, unsigned int header_num,


@@ -172,6 +173,18 @@ static inline unsigned int __hdr_size(int verify_type)
        case VERIFY_SHA512:
                len = sizeof(struct vhdr_sha512);
                break;
        case VERIFY_SHA512:
                len = sizeof(struct vhdr_sha512);
                break;

+       case VERIFY_SHA3_224:
+               len = sizeof(struct vhdr_sha3_224);
+               break;
+       case VERIFY_SHA3_256:
+               len = sizeof(struct vhdr_sha3_256);
+               break;
+       case VERIFY_SHA3_384:
+               len = sizeof(struct vhdr_sha3_384);
+               break;
+       case VERIFY_SHA3_512:
+               len = sizeof(struct vhdr_sha3_512);
+               break;

        case VERIFY_XXHASH:
                len = sizeof(struct vhdr_xxhash);
                break;
        case VERIFY_XXHASH:
                len = sizeof(struct vhdr_xxhash);
                break;


@@ -431,6 +444,84 @@ static int verify_io_u_xxhash(struct verify_header *hdr, struct vcont *vc)
        return EILSEQ;
 }
 
        return EILSEQ;
 }
 

+static int verify_io_u_sha3(struct verify_header *hdr, struct vcont *vc,
+                           struct fio_sha3_ctx *sha3_ctx, uint8_t *sha,
+                           unsigned int sha_size, const char *name)
+{
+       void *p = io_u_verify_off(hdr, vc);
+
+       dprint(FD_VERIFY, "%s verify io_u %p, len %u\n", name, vc->io_u, hdr->len);
+
+       fio_sha3_update(sha3_ctx, p, hdr->len - hdr_size(vc->td, hdr));
+       fio_sha3_final(sha3_ctx);
+
+       if (!memcmp(sha, sha3_ctx->sha, sha_size))
+               return 0;
+
+       vc->name = name;
+       vc->good_crc = sha;
+       vc->bad_crc = sha3_ctx->sha;
+       vc->crc_len = sha_size;
+       log_verify_failure(hdr, vc);
+       return EILSEQ;
+}
+
+static int verify_io_u_sha3_224(struct verify_header *hdr, struct vcont *vc)
+{
+       struct vhdr_sha3_224 *vh = hdr_priv(hdr);
+       uint8_t sha[SHA3_224_DIGEST_SIZE];
+       struct fio_sha3_ctx sha3_ctx = {
+               .sha = sha,
+       };
+
+       fio_sha3_224_init(&sha3_ctx);
+
+       return verify_io_u_sha3(hdr, vc, &sha3_ctx, vh->sha,
+                               SHA3_224_DIGEST_SIZE, "sha3-224");
+}
+
+static int verify_io_u_sha3_256(struct verify_header *hdr, struct vcont *vc)
+{
+       struct vhdr_sha3_256 *vh = hdr_priv(hdr);
+       uint8_t sha[SHA3_256_DIGEST_SIZE];
+       struct fio_sha3_ctx sha3_ctx = {
+               .sha = sha,
+       };
+
+       fio_sha3_256_init(&sha3_ctx);
+
+       return verify_io_u_sha3(hdr, vc, &sha3_ctx, vh->sha,
+                               SHA3_256_DIGEST_SIZE, "sha3-256");
+}
+
+static int verify_io_u_sha3_384(struct verify_header *hdr, struct vcont *vc)
+{
+       struct vhdr_sha3_384 *vh = hdr_priv(hdr);
+       uint8_t sha[SHA3_384_DIGEST_SIZE];
+       struct fio_sha3_ctx sha3_ctx = {
+               .sha = sha,
+       };
+
+       fio_sha3_384_init(&sha3_ctx);
+
+       return verify_io_u_sha3(hdr, vc, &sha3_ctx, vh->sha,
+                               SHA3_384_DIGEST_SIZE, "sha3-384");
+}
+
+static int verify_io_u_sha3_512(struct verify_header *hdr, struct vcont *vc)
+{
+       struct vhdr_sha3_512 *vh = hdr_priv(hdr);
+       uint8_t sha[SHA3_512_DIGEST_SIZE];
+       struct fio_sha3_ctx sha3_ctx = {
+               .sha = sha,
+       };
+
+       fio_sha3_512_init(&sha3_ctx);
+
+       return verify_io_u_sha3(hdr, vc, &sha3_ctx, vh->sha,
+                               SHA3_512_DIGEST_SIZE, "sha3-512");
+}
+

 static int verify_io_u_sha512(struct verify_header *hdr, struct vcont *vc)
 {
        void *p = io_u_verify_off(hdr, vc);
 static int verify_io_u_sha512(struct verify_header *hdr, struct vcont *vc)
 {
        void *p = io_u_verify_off(hdr, vc);


@@ -882,6 +973,18 @@ int verify_io_u(struct thread_data *td, struct io_u **io_u_ptr)
                case VERIFY_SHA512:
                        ret = verify_io_u_sha512(hdr, &vc);
                        break;
                case VERIFY_SHA512:
                        ret = verify_io_u_sha512(hdr, &vc);
                        break;

+               case VERIFY_SHA3_224:
+                       ret = verify_io_u_sha3_224(hdr, &vc);
+                       break;
+               case VERIFY_SHA3_256:
+                       ret = verify_io_u_sha3_256(hdr, &vc);
+                       break;
+               case VERIFY_SHA3_384:
+                       ret = verify_io_u_sha3_384(hdr, &vc);
+                       break;
+               case VERIFY_SHA3_512:
+                       ret = verify_io_u_sha3_512(hdr, &vc);
+                       break;

                case VERIFY_XXHASH:
                        ret = verify_io_u_xxhash(hdr, &vc);
                        break;
                case VERIFY_XXHASH:
                        ret = verify_io_u_xxhash(hdr, &vc);
                        break;


@@ -919,6 +1022,56 @@ static void fill_xxhash(struct verify_header *hdr, void *p, unsigned int len)
        vh->hash = XXH32_digest(state);
 }
 
        vh->hash = XXH32_digest(state);
 }
 

+static void fill_sha3(struct fio_sha3_ctx *sha3_ctx, void *p, unsigned int len)
+{
+       fio_sha3_update(sha3_ctx, p, len);
+       fio_sha3_final(sha3_ctx);
+}
+
+static void fill_sha3_224(struct verify_header *hdr, void *p, unsigned int len)
+{
+       struct vhdr_sha3_224 *vh = hdr_priv(hdr);
+       struct fio_sha3_ctx sha3_ctx = {
+               .sha = vh->sha,
+       };
+
+       fio_sha3_224_init(&sha3_ctx);
+       fill_sha3(&sha3_ctx, p, len);
+}
+
+static void fill_sha3_256(struct verify_header *hdr, void *p, unsigned int len)
+{
+       struct vhdr_sha3_256 *vh = hdr_priv(hdr);
+       struct fio_sha3_ctx sha3_ctx = {
+               .sha = vh->sha,
+       };
+
+       fio_sha3_256_init(&sha3_ctx);
+       fill_sha3(&sha3_ctx, p, len);
+}
+
+static void fill_sha3_384(struct verify_header *hdr, void *p, unsigned int len)
+{
+       struct vhdr_sha3_384 *vh = hdr_priv(hdr);
+       struct fio_sha3_ctx sha3_ctx = {
+               .sha = vh->sha,
+       };
+
+       fio_sha3_384_init(&sha3_ctx);
+       fill_sha3(&sha3_ctx, p, len);
+}
+
+static void fill_sha3_512(struct verify_header *hdr, void *p, unsigned int len)
+{
+       struct vhdr_sha3_512 *vh = hdr_priv(hdr);
+       struct fio_sha3_ctx sha3_ctx = {
+               .sha = vh->sha,
+       };
+
+       fio_sha3_512_init(&sha3_ctx);
+       fill_sha3(&sha3_ctx, p, len);
+}
+

 static void fill_sha512(struct verify_header *hdr, void *p, unsigned int len)
 {
        struct vhdr_sha512 *vh = hdr_priv(hdr);
 static void fill_sha512(struct verify_header *hdr, void *p, unsigned int len)
 {
        struct vhdr_sha512 *vh = hdr_priv(hdr);


@@ -1085,6 +1238,26 @@ static void populate_hdr(struct thread_data *td, struct io_u *io_u,
                                                io_u, hdr->len);
                fill_sha512(hdr, data, data_len);
                break;
                                                io_u, hdr->len);
                fill_sha512(hdr, data, data_len);
                break;

+       case VERIFY_SHA3_224:
+               dprint(FD_VERIFY, "fill sha3-224 io_u %p, len %u\n",
+                                               io_u, hdr->len);
+               fill_sha3_224(hdr, data, data_len);
+               break;
+       case VERIFY_SHA3_256:
+               dprint(FD_VERIFY, "fill sha3-256 io_u %p, len %u\n",
+                                               io_u, hdr->len);
+               fill_sha3_256(hdr, data, data_len);
+               break;
+       case VERIFY_SHA3_384:
+               dprint(FD_VERIFY, "fill sha3-384 io_u %p, len %u\n",
+                                               io_u, hdr->len);
+               fill_sha3_384(hdr, data, data_len);
+               break;
+       case VERIFY_SHA3_512:
+               dprint(FD_VERIFY, "fill sha3-512 io_u %p, len %u\n",
+                                               io_u, hdr->len);
+               fill_sha3_512(hdr, data, data_len);
+               break;

        case VERIFY_XXHASH:
                dprint(FD_VERIFY, "fill xxhash io_u %p, len %u\n",
                                                io_u, hdr->len);
        case VERIFY_XXHASH:
                dprint(FD_VERIFY, "fill xxhash io_u %p, len %u\n",
                                                io_u, hdr->len);

diff --git a/verify.h b/verify.h
index deb161e2a99db3d96fb97395ae4041e4a389ed57..5aae2e7e9bb411f9be2e964fb023baf023ca5bea 100644 (file)
--- a/verify.h
+++ b/verify.h
@@ -20,6 +20,10 @@ enum {
        VERIFY_CRC7,                    /* crc7 sum data blocks */
        VERIFY_SHA256,                  /* sha256 sum data blocks */
        VERIFY_SHA512,                  /* sha512 sum data blocks */
        VERIFY_CRC7,                    /* crc7 sum data blocks */
        VERIFY_SHA256,                  /* sha256 sum data blocks */
        VERIFY_SHA512,                  /* sha512 sum data blocks */

+       VERIFY_SHA3_224,                /* sha3-224 sum data blocks */
+       VERIFY_SHA3_256,                /* sha3-256 sum data blocks */
+       VERIFY_SHA3_384,                /* sha3-384 sum data blocks */
+       VERIFY_SHA3_512,                /* sha3-512 sum data blocks */

        VERIFY_XXHASH,                  /* xxhash sum data blocks */
        VERIFY_SHA1,                    /* sha1 sum data blocks */
        VERIFY_PATTERN,                 /* verify specific patterns */
        VERIFY_XXHASH,                  /* xxhash sum data blocks */
        VERIFY_SHA1,                    /* sha1 sum data blocks */
        VERIFY_PATTERN,                 /* verify specific patterns */


@@ -48,6 +52,18 @@ struct verify_header {
 struct vhdr_md5 {
        uint32_t md5_digest[4];
 };
 struct vhdr_md5 {
        uint32_t md5_digest[4];
 };

+struct vhdr_sha3_224 {
+       uint8_t sha[224 / 8];
+};
+struct vhdr_sha3_256 {
+       uint8_t sha[256 / 8];
+};
+struct vhdr_sha3_384 {
+       uint8_t sha[384 / 8];
+};
+struct vhdr_sha3_512 {
+       uint8_t sha[512 / 8];
+};

 struct vhdr_sha512 {
        uint8_t sha512[128];
 };
 struct vhdr_sha512 {
        uint8_t sha512[128];
 };