crypto: tcrypt - Use skcipher

This patch converts tcrypt to use the new skcipher interface as
opposed to ablkcipher/blkcipher.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/crypto/tcrypt.c b/crypto/tcrypt.c
index 8a91dc3..68064fc 100644 (file)
--- a/crypto/tcrypt.c
+++ b/crypto/tcrypt.c
@@ -24,6 +24,7 @@
 
 #include <crypto/aead.h>
 #include <crypto/hash.h>
+#include <crypto/skcipher.h>
 #include <linux/err.h>
 #include <linux/fips.h>
 #include <linux/init.h>
@@ -92,76 +93,6 @@ static void tcrypt_complete(struct crypto_async_request *req, int err)
        complete(&res->completion);
 }
 
-static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
-                              struct scatterlist *sg, int blen, int secs)
-{
-       unsigned long start, end;
-       int bcount;
-       int ret;
-
-       for (start = jiffies, end = start + secs * HZ, bcount = 0;
-            time_before(jiffies, end); bcount++) {
-               if (enc)
-                       ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
-               else
-                       ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
-
-               if (ret)
-                       return ret;
-       }
-
-       printk("%d operations in %d seconds (%ld bytes)\n",
-              bcount, secs, (long)bcount * blen);
-       return 0;
-}
-
-static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
-                             struct scatterlist *sg, int blen)
-{
-       unsigned long cycles = 0;
-       int ret = 0;
-       int i;
-
-       local_irq_disable();
-
-       /* Warm-up run. */
-       for (i = 0; i < 4; i++) {
-               if (enc)
-                       ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
-               else
-                       ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
-
-               if (ret)
-                       goto out;
-       }
-
-       /* The real thing. */
-       for (i = 0; i < 8; i++) {
-               cycles_t start, end;
-
-               start = get_cycles();
-               if (enc)
-                       ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
-               else
-                       ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
-               end = get_cycles();
-
-               if (ret)
-                       goto out;
-
-               cycles += end - start;
-       }
-
-out:
-       local_irq_enable();
-
-       if (ret == 0)
-               printk("1 operation in %lu cycles (%d bytes)\n",
-                      (cycles + 4) / 8, blen);
-
-       return ret;
-}
-
 static inline int do_one_aead_op(struct aead_request *req, int ret)
 {
        if (ret == -EINPROGRESS || ret == -EBUSY) {
@@ -455,106 +386,6 @@ out_noxbuf:
        return;
 }
 
-static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
-                             struct cipher_speed_template *template,
-                             unsigned int tcount, u8 *keysize)
-{
-       unsigned int ret, i, j, iv_len;
-       const char *key;
-       char iv[128];
-       struct crypto_blkcipher *tfm;
-       struct blkcipher_desc desc;
-       const char *e;
-       u32 *b_size;
-
-       if (enc == ENCRYPT)
-               e = "encryption";
-       else
-               e = "decryption";
-
-       tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
-
-       if (IS_ERR(tfm)) {
-               printk("failed to load transform for %s: %ld\n", algo,
-                      PTR_ERR(tfm));
-               return;
-       }
-       desc.tfm = tfm;
-       desc.flags = 0;
-
-       printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
-                       get_driver_name(crypto_blkcipher, tfm), e);
-
-       i = 0;
-       do {
-
-               b_size = block_sizes;
-               do {
-                       struct scatterlist sg[TVMEMSIZE];
-
-                       if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
-                               printk("template (%u) too big for "
-                                      "tvmem (%lu)\n", *keysize + *b_size,
-                                      TVMEMSIZE * PAGE_SIZE);
-                               goto out;
-                       }
-
-                       printk("test %u (%d bit key, %d byte blocks): ", i,
-                                       *keysize * 8, *b_size);
-
-                       memset(tvmem[0], 0xff, PAGE_SIZE);
-
-                       /* set key, plain text and IV */
-                       key = tvmem[0];
-                       for (j = 0; j < tcount; j++) {
-                               if (template[j].klen == *keysize) {
-                                       key = template[j].key;
-                                       break;
-                               }
-                       }
-
-                       ret = crypto_blkcipher_setkey(tfm, key, *keysize);
-                       if (ret) {
-                               printk("setkey() failed flags=%x\n",
-                                               crypto_blkcipher_get_flags(tfm));
-                               goto out;
-                       }
-
-                       sg_init_table(sg, TVMEMSIZE);
-                       sg_set_buf(sg, tvmem[0] + *keysize,
-                                  PAGE_SIZE - *keysize);
-                       for (j = 1; j < TVMEMSIZE; j++) {
-                               sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
-                               memset (tvmem[j], 0xff, PAGE_SIZE);
-                       }
-
-                       iv_len = crypto_blkcipher_ivsize(tfm);
-                       if (iv_len) {
-                               memset(&iv, 0xff, iv_len);
-                               crypto_blkcipher_set_iv(tfm, iv, iv_len);
-                       }
-
-                       if (secs)
-                               ret = test_cipher_jiffies(&desc, enc, sg,
-                                                         *b_size, secs);
-                       else
-                               ret = test_cipher_cycles(&desc, enc, sg,
-                                                        *b_size);
-
-                       if (ret) {
-                               printk("%s() failed flags=%x\n", e, desc.flags);
-                               break;
-                       }
-                       b_size++;
-                       i++;
-               } while (*b_size);
-               keysize++;
-       } while (*keysize);
-
-out:
-       crypto_free_blkcipher(tfm);
-}
-
 static void test_hash_sg_init(struct scatterlist *sg)
 {
        int i;
@@ -932,7 +763,7 @@ static void test_hash_speed(const char *algo, unsigned int secs,
        return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC);
 }
 
-static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
+static inline int do_one_acipher_op(struct skcipher_request *req, int ret)
 {
        if (ret == -EINPROGRESS || ret == -EBUSY) {
                struct tcrypt_result *tr = req->base.data;
@@ -945,7 +776,7 @@ static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
        return ret;
 }
 
-static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
+static int test_acipher_jiffies(struct skcipher_request *req, int enc,
                                int blen, int secs)
 {
        unsigned long start, end;
@@ -956,10 +787,10 @@ static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
             time_before(jiffies, end); bcount++) {
                if (enc)
                        ret = do_one_acipher_op(req,
-                                               crypto_ablkcipher_encrypt(req));
+                                               crypto_skcipher_encrypt(req));
                else
                        ret = do_one_acipher_op(req,
-                                               crypto_ablkcipher_decrypt(req));
+                                               crypto_skcipher_decrypt(req));
 
                if (ret)
                        return ret;
@@ -970,7 +801,7 @@ static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
        return 0;
 }
 
-static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
+static int test_acipher_cycles(struct skcipher_request *req, int enc,
                               int blen)
 {
        unsigned long cycles = 0;
@@ -981,10 +812,10 @@ static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
        for (i = 0; i < 4; i++) {
                if (enc)
                        ret = do_one_acipher_op(req,
-                                               crypto_ablkcipher_encrypt(req));
+                                               crypto_skcipher_encrypt(req));
                else
                        ret = do_one_acipher_op(req,
-                                               crypto_ablkcipher_decrypt(req));
+                                               crypto_skcipher_decrypt(req));
 
                if (ret)
                        goto out;
@@ -997,10 +828,10 @@ static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
                start = get_cycles();
                if (enc)
                        ret = do_one_acipher_op(req,
-                                               crypto_ablkcipher_encrypt(req));
+                                               crypto_skcipher_encrypt(req));
                else
                        ret = do_one_acipher_op(req,
-                                               crypto_ablkcipher_decrypt(req));
+                                               crypto_skcipher_decrypt(req));
                end = get_cycles();
 
                if (ret)
@@ -1017,16 +848,16 @@ out:
        return ret;
 }
 
-static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
-                              struct cipher_speed_template *template,
-                              unsigned int tcount, u8 *keysize)
+static void test_skcipher_speed(const char *algo, int enc, unsigned int secs,
+                               struct cipher_speed_template *template,
+                               unsigned int tcount, u8 *keysize, bool async)
 {
        unsigned int ret, i, j, k, iv_len;
        struct tcrypt_result tresult;
        const char *key;
        char iv[128];
-       struct ablkcipher_request *req;
-       struct crypto_ablkcipher *tfm;
+       struct skcipher_request *req;
+       struct crypto_skcipher *tfm;
        const char *e;
        u32 *b_size;
 
@@ -1037,7 +868,7 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
 
        init_completion(&tresult.completion);
 
-       tfm = crypto_alloc_ablkcipher(algo, 0, 0);
+       tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC);
 
        if (IS_ERR(tfm)) {
                pr_err("failed to load transform for %s: %ld\n", algo,
@@ -1046,17 +877,17 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
        }
 
        pr_info("\ntesting speed of async %s (%s) %s\n", algo,
-                       get_driver_name(crypto_ablkcipher, tfm), e);
+                       get_driver_name(crypto_skcipher, tfm), e);
 
-       req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
+       req = skcipher_request_alloc(tfm, GFP_KERNEL);
        if (!req) {
                pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
                       algo);
                goto out;
        }
 
-       ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
-                                       tcrypt_complete, &tresult);
+       skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
+                                     tcrypt_complete, &tresult);
 
        i = 0;
        do {
@@ -1086,12 +917,12 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
                                }
                        }
 
-                       crypto_ablkcipher_clear_flags(tfm, ~0);
+                       crypto_skcipher_clear_flags(tfm, ~0);
 
-                       ret = crypto_ablkcipher_setkey(tfm, key, *keysize);
+                       ret = crypto_skcipher_setkey(tfm, key, *keysize);
                        if (ret) {
                                pr_err("setkey() failed flags=%x\n",
-                                       crypto_ablkcipher_get_flags(tfm));
+                                       crypto_skcipher_get_flags(tfm));
                                goto out_free_req;
                        }
 
@@ -1115,11 +946,11 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
                                sg_set_buf(sg, tvmem[0] + *keysize, *b_size);
                        }
 
-                       iv_len = crypto_ablkcipher_ivsize(tfm);
+                       iv_len = crypto_skcipher_ivsize(tfm);
                        if (iv_len)
                                memset(&iv, 0xff, iv_len);
 
-                       ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);
+                       skcipher_request_set_crypt(req, sg, sg, *b_size, iv);
 
                        if (secs)
                                ret = test_acipher_jiffies(req, enc,
@@ -1130,7 +961,7 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
 
                        if (ret) {
                                pr_err("%s() failed flags=%x\n", e,
-                                       crypto_ablkcipher_get_flags(tfm));
+                                      crypto_skcipher_get_flags(tfm));
                                break;
                        }
                        b_size++;
@@ -1140,9 +971,25 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
        } while (*keysize);
 
 out_free_req:
-       ablkcipher_request_free(req);
+       skcipher_request_free(req);
 out:
-       crypto_free_ablkcipher(tfm);
+       crypto_free_skcipher(tfm);
+}
+
+static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
+                              struct cipher_speed_template *template,
+                              unsigned int tcount, u8 *keysize)
+{
+       return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
+                                  true);
+}
+
+static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
+                             struct cipher_speed_template *template,
+                             unsigned int tcount, u8 *keysize)
+{
+       return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
+                                  false);
 }
 
 static void test_available(void)