[CRYPTO] api: Add async blkcipher type

This patch adds the mid-level interface for asynchronous block ciphers.
It also includes a generic queueing mechanism that can be used by other
asynchronous crypto operations in future.

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

4 files changed, 150 insertions, 0 deletions

diff --git a/crypto/Kconfig b/crypto/Kconfig
index 086fcec44720..a20a3f14d324 100644
--- a/crypto/Kconfig
+++ b/crypto/Kconfig
@@ -16,6 +16,10 @@ config CRYPTO_ALGAPI
         help
           This option provides the API for cryptographic algorithms.
 
+config CRYPTO_ABLKCIPHER
+        tristate
+        select CRYPTO_BLKCIPHER
+
 config CRYPTO_BLKCIPHER
         tristate
         select CRYPTO_ALGAPI
diff --git a/crypto/Makefile b/crypto/Makefile
index 12f93f578171..3820d4c5ccc2 100644
--- a/crypto/Makefile
+++ b/crypto/Makefile
@@ -8,6 +8,7 @@ crypto_algapi-$(CONFIG_PROC_FS) += proc.o
 crypto_algapi-objs := algapi.o $(crypto_algapi-y)
 obj-$(CONFIG_CRYPTO_ALGAPI) += crypto_algapi.o
 
+obj-$(CONFIG_CRYPTO_ABLKCIPHER) += ablkcipher.o
 obj-$(CONFIG_CRYPTO_BLKCIPHER) += blkcipher.o
 
 crypto_hash-objs := hash.o
diff --git a/crypto/ablkcipher.c b/crypto/ablkcipher.c
new file mode 100644
index 000000000000..9348ddd84a56
--- /dev/null
+++ b/crypto/ablkcipher.c
@@ -0,0 +1,83 @@
+/*
+ * Asynchronous block chaining cipher operations.
+ * 
+ * This is the asynchronous version of blkcipher.c indicating completion
+ * via a callback.
+ *
+ * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option) 
+ * any later version.
+ *
+ */
+
+#include <crypto/algapi.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/seq_file.h>
+
+static int setkey(struct crypto_ablkcipher *tfm, const u8 *key,
+                  unsigned int keylen)
+{
+        struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);
+
+        if (keylen < cipher->min_keysize || keylen > cipher->max_keysize) {
+                crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
+                return -EINVAL;
+        }
+
+        return cipher->setkey(tfm, key, keylen);
+}
+
+static unsigned int crypto_ablkcipher_ctxsize(struct crypto_alg *alg, u32 type,
+                                              u32 mask)
+{
+        return alg->cra_ctxsize;
+}
+
+static int crypto_init_ablkcipher_ops(struct crypto_tfm *tfm, u32 type,
+                                      u32 mask)
+{
+        struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
+        struct ablkcipher_tfm *crt = &tfm->crt_ablkcipher;
+
+        if (alg->ivsize > PAGE_SIZE / 8)
+                return -EINVAL;
+
+        crt->setkey = setkey;
+        crt->encrypt = alg->encrypt;
+        crt->decrypt = alg->decrypt;
+        crt->ivsize = alg->ivsize;
+
+        return 0;
+}
+
+static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
+        __attribute__ ((unused));
+static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
+{
+        struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;
+
+        seq_printf(m, "type         : ablkcipher\n");
+        seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
+        seq_printf(m, "min keysize  : %u\n", ablkcipher->min_keysize);
+        seq_printf(m, "max keysize  : %u\n", ablkcipher->max_keysize);
+        seq_printf(m, "ivsize       : %u\n", ablkcipher->ivsize);
+        seq_printf(m, "qlen         : %u\n", ablkcipher->queue->qlen);
+        seq_printf(m, "max qlen     : %u\n", ablkcipher->queue->max_qlen);
+}
+
+const struct crypto_type crypto_ablkcipher_type = {
+        .ctxsize = crypto_ablkcipher_ctxsize,
+        .init = crypto_init_ablkcipher_ops,
+#ifdef CONFIG_PROC_FS
+        .show = crypto_ablkcipher_show,
+#endif
+};
+EXPORT_SYMBOL_GPL(crypto_ablkcipher_type);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Asynchronous block chaining cipher type");
diff --git a/crypto/algapi.c b/crypto/algapi.c
index 491205e11cbe..1c2185b5b005 100644
--- a/crypto/algapi.c
+++ b/crypto/algapi.c
@@ -507,6 +507,68 @@ err_free_inst:
 }
 EXPORT_SYMBOL_GPL(crypto_alloc_instance);
 
+void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen)
+{
+        INIT_LIST_HEAD(&queue->list);
+        queue->backlog = &queue->list;
+        queue->qlen = 0;
+        queue->max_qlen = max_qlen;
+}
+EXPORT_SYMBOL_GPL(crypto_init_queue);
+
+int crypto_enqueue_request(struct crypto_queue *queue,
+                           struct crypto_async_request *request)
+{
+        int err = -EINPROGRESS;
+
+        if (unlikely(queue->qlen >= queue->max_qlen)) {
+                err = -EBUSY;
+                if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
+                        goto out;
+                if (queue->backlog == &queue->list)
+                        queue->backlog = &request->list;
+        }
+
+        queue->qlen++;
+        list_add_tail(&request->list, &queue->list);
+
+out:
+        return err;
+}
+EXPORT_SYMBOL_GPL(crypto_enqueue_request);
+
+struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue)
+{
+        struct list_head *request;
+
+        if (unlikely(!queue->qlen))
+                return NULL;
+
+        queue->qlen--;
+
+        if (queue->backlog != &queue->list)
+                queue->backlog = queue->backlog->next;
+
+        request = queue->list.next;
+        list_del(request);
+
+        return list_entry(request, struct crypto_async_request, list);
+}
+EXPORT_SYMBOL_GPL(crypto_dequeue_request);
+
+int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm)
+{
+        struct crypto_async_request *req;
+
+        list_for_each_entry(req, &queue->list, list) {
+                if (req->tfm == tfm)
+                        return 1;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(crypto_tfm_in_queue);
+
 static int __init crypto_algapi_init(void)
 {
         crypto_init_proc();