mm, numa: reclaim from all nodes within reclaim distance
[linux-3.10.git] / crypto / tcrypt.c
index 91f3ab4..e87fa60 100644 (file)
@@ -97,7 +97,6 @@ static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
        int ret = 0;
        int i;
 
-       local_bh_disable();
        local_irq_disable();
 
        /* Warm-up run. */
@@ -130,7 +129,6 @@ static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
 
 out:
        local_irq_enable();
-       local_bh_enable();
 
        if (ret == 0)
                printk("1 operation in %lu cycles (%d bytes)\n",
@@ -300,7 +298,6 @@ static int test_hash_cycles_digest(struct hash_desc *desc,
        int i;
        int ret;
 
-       local_bh_disable();
        local_irq_disable();
 
        /* Warm-up run. */
@@ -327,7 +324,6 @@ static int test_hash_cycles_digest(struct hash_desc *desc,
 
 out:
        local_irq_enable();
-       local_bh_enable();
 
        if (ret)
                return ret;
@@ -348,7 +344,6 @@ static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
        if (plen == blen)
                return test_hash_cycles_digest(desc, sg, blen, out);
 
-       local_bh_disable();
        local_irq_disable();
 
        /* Warm-up run. */
@@ -391,7 +386,6 @@ static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
 
 out:
        local_irq_enable();
-       local_bh_enable();
 
        if (ret)
                return ret;
@@ -719,6 +713,219 @@ out:
        crypto_free_ahash(tfm);
 }
 
+static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
+{
+       if (ret == -EINPROGRESS || ret == -EBUSY) {
+               struct tcrypt_result *tr = req->base.data;
+
+               ret = wait_for_completion_interruptible(&tr->completion);
+               if (!ret)
+                       ret = tr->err;
+               INIT_COMPLETION(tr->completion);
+       }
+
+       return ret;
+}
+
+static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
+                               int blen, int sec)
+{
+       unsigned long start, end;
+       int bcount;
+       int ret;
+
+       for (start = jiffies, end = start + sec * HZ, bcount = 0;
+            time_before(jiffies, end); bcount++) {
+               if (enc)
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_encrypt(req));
+               else
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_decrypt(req));
+
+               if (ret)
+                       return ret;
+       }
+
+       pr_cont("%d operations in %d seconds (%ld bytes)\n",
+               bcount, sec, (long)bcount * blen);
+       return 0;
+}
+
+static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
+                              int blen)
+{
+       unsigned long cycles = 0;
+       int ret = 0;
+       int i;
+
+       /* Warm-up run. */
+       for (i = 0; i < 4; i++) {
+               if (enc)
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_encrypt(req));
+               else
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_decrypt(req));
+
+               if (ret)
+                       goto out;
+       }
+
+       /* The real thing. */
+       for (i = 0; i < 8; i++) {
+               cycles_t start, end;
+
+               start = get_cycles();
+               if (enc)
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_encrypt(req));
+               else
+                       ret = do_one_acipher_op(req,
+                                               crypto_ablkcipher_decrypt(req));
+               end = get_cycles();
+
+               if (ret)
+                       goto out;
+
+               cycles += end - start;
+       }
+
+out:
+       if (ret == 0)
+               pr_cont("1 operation in %lu cycles (%d bytes)\n",
+                       (cycles + 4) / 8, blen);
+
+       return ret;
+}
+
+static void test_acipher_speed(const char *algo, int enc, unsigned int sec,
+                              struct cipher_speed_template *template,
+                              unsigned int tcount, u8 *keysize)
+{
+       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;
+       const char *e;
+       u32 *b_size;
+
+       if (enc == ENCRYPT)
+               e = "encryption";
+       else
+               e = "decryption";
+
+       pr_info("\ntesting speed of async %s %s\n", algo, e);
+
+       init_completion(&tresult.completion);
+
+       tfm = crypto_alloc_ablkcipher(algo, 0, 0);
+
+       if (IS_ERR(tfm)) {
+               pr_err("failed to load transform for %s: %ld\n", algo,
+                      PTR_ERR(tfm));
+               return;
+       }
+
+       req = ablkcipher_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);
+
+       i = 0;
+       do {
+               b_size = block_sizes;
+
+               do {
+                       struct scatterlist sg[TVMEMSIZE];
+
+                       if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
+                               pr_err("template (%u) too big for "
+                                      "tvmem (%lu)\n", *keysize + *b_size,
+                                      TVMEMSIZE * PAGE_SIZE);
+                               goto out_free_req;
+                       }
+
+                       pr_info("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;
+                               }
+                       }
+
+                       crypto_ablkcipher_clear_flags(tfm, ~0);
+
+                       ret = crypto_ablkcipher_setkey(tfm, key, *keysize);
+                       if (ret) {
+                               pr_err("setkey() failed flags=%x\n",
+                                       crypto_ablkcipher_get_flags(tfm));
+                               goto out_free_req;
+                       }
+
+                       sg_init_table(sg, TVMEMSIZE);
+
+                       k = *keysize + *b_size;
+                       if (k > PAGE_SIZE) {
+                               sg_set_buf(sg, tvmem[0] + *keysize,
+                                  PAGE_SIZE - *keysize);
+                               k -= PAGE_SIZE;
+                               j = 1;
+                               while (k > PAGE_SIZE) {
+                                       sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
+                                       memset(tvmem[j], 0xff, PAGE_SIZE);
+                                       j++;
+                                       k -= PAGE_SIZE;
+                               }
+                               sg_set_buf(sg + j, tvmem[j], k);
+                               memset(tvmem[j], 0xff, k);
+                       } else {
+                               sg_set_buf(sg, tvmem[0] + *keysize, *b_size);
+                       }
+
+                       iv_len = crypto_ablkcipher_ivsize(tfm);
+                       if (iv_len)
+                               memset(&iv, 0xff, iv_len);
+
+                       ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);
+
+                       if (sec)
+                               ret = test_acipher_jiffies(req, enc,
+                                                          *b_size, sec);
+                       else
+                               ret = test_acipher_cycles(req, enc,
+                                                         *b_size);
+
+                       if (ret) {
+                               pr_err("%s() failed flags=%x\n", e,
+                                       crypto_ablkcipher_get_flags(tfm));
+                               break;
+                       }
+                       b_size++;
+                       i++;
+               } while (*b_size);
+               keysize++;
+       } while (*keysize);
+
+out_free_req:
+       ablkcipher_request_free(req);
+out:
+       crypto_free_ablkcipher(tfm);
+}
+
 static void test_available(void)
 {
        char **name = check;
@@ -788,10 +995,17 @@ static int do_test(int m)
        case 8:
                ret += tcrypt_test("ecb(twofish)");
                ret += tcrypt_test("cbc(twofish)");
+               ret += tcrypt_test("ctr(twofish)");
+               ret += tcrypt_test("lrw(twofish)");
+               ret += tcrypt_test("xts(twofish)");
                break;
 
        case 9:
                ret += tcrypt_test("ecb(serpent)");
+               ret += tcrypt_test("cbc(serpent)");
+               ret += tcrypt_test("ctr(serpent)");
+               ret += tcrypt_test("lrw(serpent)");
+               ret += tcrypt_test("xts(serpent)");
                break;
 
        case 10:
@@ -817,10 +1031,16 @@ static int do_test(int m)
 
        case 14:
                ret += tcrypt_test("ecb(cast5)");
+               ret += tcrypt_test("cbc(cast5)");
+               ret += tcrypt_test("ctr(cast5)");
                break;
 
        case 15:
                ret += tcrypt_test("ecb(cast6)");
+               ret += tcrypt_test("cbc(cast6)");
+               ret += tcrypt_test("ctr(cast6)");
+               ret += tcrypt_test("lrw(cast6)");
+               ret += tcrypt_test("xts(cast6)");
                break;
 
        case 16:
@@ -892,6 +1112,9 @@ static int do_test(int m)
        case 32:
                ret += tcrypt_test("ecb(camellia)");
                ret += tcrypt_test("cbc(camellia)");
+               ret += tcrypt_test("ctr(camellia)");
+               ret += tcrypt_test("lrw(camellia)");
+               ret += tcrypt_test("xts(camellia)");
                break;
        case 33:
                ret += tcrypt_test("sha224");
@@ -945,6 +1168,10 @@ static int do_test(int m)
                ret += tcrypt_test("rfc4309(ccm(aes))");
                break;
 
+       case 46:
+               ret += tcrypt_test("ghash");
+               break;
+
        case 100:
                ret += tcrypt_test("hmac(md5)");
                break;
@@ -984,6 +1211,9 @@ static int do_test(int m)
        case 109:
                ret += tcrypt_test("vmac(aes)");
                break;
+       case 110:
+               ret += tcrypt_test("hmac(crc32)");
+               break;
 
        case 150:
                ret += tcrypt_test("ansi_cprng");
@@ -1044,6 +1274,14 @@ static int do_test(int m)
                                speed_template_16_24_32);
                test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
                                speed_template_16_24_32);
+               test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
+               test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
                break;
 
        case 203:
@@ -1081,6 +1319,18 @@ static int do_test(int m)
                                speed_template_16_24_32);
                test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
                                speed_template_16_24_32);
+               test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
+                               speed_template_16_24_32);
+               test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_40_48);
+               test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
+               test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
+                               speed_template_32_48_64);
                break;
 
        case 206:
@@ -1088,6 +1338,72 @@ static int do_test(int m)
                                  speed_template_16_32);
                break;
 
+       case 207:
+               test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_32_48);
+               test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_32_48);
+               test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_32_64);
+               test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
+                                 speed_template_32_64);
+               break;
+
+       case 208:
+               test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8);
+               break;
+
+       case 209:
+               test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8_16);
+               test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
+                                 speed_template_8_16);
+               test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8_16);
+               test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
+                                 speed_template_8_16);
+               test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_8_16);
+               test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
+                                 speed_template_8_16);
+               break;
+
+       case 210:
+               test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
+                                 speed_template_16_32);
+               test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_32_48);
+               test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
+                                 speed_template_32_48);
+               test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
+                                 speed_template_32_64);
+               test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
+                                 speed_template_32_64);
+               break;
+
        case 300:
                /* fall through */
 
@@ -1240,6 +1556,172 @@ static int do_test(int m)
        case 499:
                break;
 
+       case 500:
+               test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_40_48);
+               test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_40_48);
+               test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_48_64);
+               test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_48_64);
+               test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               break;
+
+       case 501:
+               test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
+                                  des3_speed_template, DES3_SPEED_VECTORS,
+                                  speed_template_24);
+               break;
+
+       case 502:
+               test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               break;
+
+       case 503:
+               test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_48);
+               test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_48);
+               test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_64);
+               test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_64);
+               break;
+
+       case 504:
+               test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_24_32);
+               test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_40_48);
+               test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_40_48);
+               test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_48_64);
+               test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_48_64);
+               break;
+
+       case 505:
+               test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8);
+               break;
+
+       case 506:
+               test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8_16);
+               test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8_16);
+               test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8_16);
+               test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8_16);
+               test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_8_16);
+               test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
+                                  speed_template_8_16);
+               break;
+
+       case 507:
+               test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
+                                  speed_template_16_32);
+               test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_48);
+               test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_48);
+               test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
+                                  speed_template_32_64);
+               test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
+                                  speed_template_32_64);
+               break;
+
        case 1000:
                test_available();
                break;