Release 4.7 crypto/cryptd.c

Directory: crypto
/*
 * Software async crypto daemon.
 *
 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
 *
 * Added AEAD support to cryptd.
 *    Authors: Tadeusz Struk (tadeusz.struk@intel.com)
 *             Adrian Hoban <adrian.hoban@intel.com>
 *             Gabriele Paoloni <gabriele.paoloni@intel.com>
 *             Aidan O'Mahony (aidan.o.mahony@intel.com)
 *    Copyright (c) 2010, Intel Corporation.
 *
 * 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 <crypto/internal/hash.h>
#include <crypto/internal/aead.h>
#include <crypto/cryptd.h>
#include <crypto/crypto_wq.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/scatterlist.h>
#include <linux/sched.h>
#include <linux/slab.h>


#define CRYPTD_MAX_CPU_QLEN 100


struct cryptd_cpu_queue {
	
struct crypto_queue queue;
	
struct work_struct work;
};


struct cryptd_queue {
	
struct cryptd_cpu_queue __percpu *cpu_queue;
};


struct cryptd_instance_ctx {
	
struct crypto_spawn spawn;
	
struct cryptd_queue *queue;
};


struct hashd_instance_ctx {
	
struct crypto_shash_spawn spawn;
	
struct cryptd_queue *queue;
};


struct aead_instance_ctx {
	
struct crypto_aead_spawn aead_spawn;
	
struct cryptd_queue *queue;
};


struct cryptd_blkcipher_ctx {
	
struct crypto_blkcipher *child;
};


struct cryptd_blkcipher_request_ctx {
	
crypto_completion_t complete;
};


struct cryptd_hash_ctx {
	
struct crypto_shash *child;
};


struct cryptd_hash_request_ctx {
	
crypto_completion_t complete;
	
struct shash_desc desc;
};


struct cryptd_aead_ctx {
	
struct crypto_aead *child;
};


struct cryptd_aead_request_ctx {
	
crypto_completion_t complete;
};

static void cryptd_queue_worker(struct work_struct *work);



static int cryptd_init_queue(struct cryptd_queue *queue,
			     unsigned int max_cpu_qlen)
{
	int cpu;
	struct cryptd_cpu_queue *cpu_queue;

	queue->cpu_queue = alloc_percpu(struct cryptd_cpu_queue);
	if (!queue->cpu_queue)
		return -ENOMEM;
	for_each_possible_cpu(cpu) {
		cpu_queue = per_cpu_ptr(queue->cpu_queue, cpu);
		crypto_init_queue(&cpu_queue->queue, max_cpu_qlen);
		INIT_WORK(&cpu_queue->work, cryptd_queue_worker);
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 84 100.00% 1 100.00%
Total 84 100.00% 1 100.00%



static void cryptd_fini_queue(struct cryptd_queue *queue)
{
	int cpu;
	struct cryptd_cpu_queue *cpu_queue;

	for_each_possible_cpu(cpu) {
		cpu_queue = per_cpu_ptr(queue->cpu_queue, cpu);
		BUG_ON(cpu_queue->queue.qlen);
	}
	free_percpu(queue->cpu_queue);
}

Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 52 100.00% 1 100.00%
Total 52 100.00% 1 100.00%



static int cryptd_enqueue_request(struct cryptd_queue *queue,
				  struct crypto_async_request *request)
{
	int cpu, err;
	struct cryptd_cpu_queue *cpu_queue;

	cpu = get_cpu();
	cpu_queue = this_cpu_ptr(queue->cpu_queue);
	err = crypto_enqueue_request(&cpu_queue->queue, request);
	queue_work_on(cpu, kcrypto_wq, &cpu_queue->work);
	put_cpu();

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 69 98.57% 1 50.00%
christoph lameter christoph lameter 1 1.43% 1 50.00%
Total 70 100.00% 2 100.00%

/* Called in workqueue context, do one real cryption work (via
 * req->complete) and reschedule itself if there are more work to
 * do. */


static void cryptd_queue_worker(struct work_struct *work)
{
	struct cryptd_cpu_queue *cpu_queue;
	struct crypto_async_request *req, *backlog;

	cpu_queue = container_of(work, struct cryptd_cpu_queue, work);
	/*
         * Only handle one request at a time to avoid hogging crypto workqueue.
         * preempt_disable/enable is used to prevent being preempted by
         * cryptd_enqueue_request(). local_bh_disable/enable is used to prevent
         * cryptd_enqueue_request() being accessed from software interrupts.
         */
	local_bh_disable();
	preempt_disable();
	backlog = crypto_get_backlog(&cpu_queue->queue);
	req = crypto_dequeue_request(&cpu_queue->queue);
	preempt_enable();
	local_bh_enable();

	if (!req)
		return;

	if (backlog)
		backlog->complete(backlog, -EINPROGRESS);
	req->complete(req, 0);

	if (cpu_queue->queue.qlen)
		queue_work(kcrypto_wq, &cpu_queue->work);
}

Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 109 93.97% 1 50.00%
jussi kivilinna jussi kivilinna 7 6.03% 1 50.00%
Total 116 100.00% 2 100.00%



static inline struct cryptd_queue *cryptd_get_queue(struct crypto_tfm *tfm)
{
	struct crypto_instance *inst = crypto_tfm_alg_instance(tfm);
	struct cryptd_instance_ctx *ictx = crypto_instance_ctx(inst);
	return ictx->queue;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 36 92.31% 1 50.00%
huang ying huang ying 3 7.69% 1 50.00%
Total 39 100.00% 2 100.00%



static inline void cryptd_check_internal(struct rtattr **tb, u32 *type,
					 u32 *mask)
{
	struct crypto_attr_type *algt;

	algt = crypto_get_attr_type(tb);
	if (IS_ERR(algt))
		return;

	*type |= algt->type & CRYPTO_ALG_INTERNAL;
	*mask |= algt->mask & CRYPTO_ALG_INTERNAL;
}

Contributors
Person Tokens Prop Commits CommitProp
stephan mueller stephan mueller 54 91.53% 1 50.00%
herbert xu herbert xu 5 8.47% 1 50.00%
Total 59 100.00% 2 100.00%



static int cryptd_blkcipher_setkey(struct crypto_ablkcipher *parent,
				   const u8 *key, unsigned int keylen)
{
	struct cryptd_blkcipher_ctx *ctx = crypto_ablkcipher_ctx(parent);
	struct crypto_blkcipher *child = ctx->child;
	int err;

	crypto_blkcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
	crypto_blkcipher_set_flags(child, crypto_ablkcipher_get_flags(parent) &
					  CRYPTO_TFM_REQ_MASK);
	err = crypto_blkcipher_setkey(child, key, keylen);
	crypto_ablkcipher_set_flags(parent, crypto_blkcipher_get_flags(child) &
					    CRYPTO_TFM_RES_MASK);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 87 100.00% 1 100.00%
Total 87 100.00% 1 100.00%



static void cryptd_blkcipher_crypt(struct ablkcipher_request *req,
				   struct crypto_blkcipher *child,
				   int err,
				   int (*crypt)(struct blkcipher_desc *desc,
						struct scatterlist *dst,
						struct scatterlist *src,
						unsigned int len))
{
	struct cryptd_blkcipher_request_ctx *rctx;
	struct blkcipher_desc desc;

	rctx = ablkcipher_request_ctx(req);

	if (unlikely(err == -EINPROGRESS))
		goto out;

	desc.tfm = child;
	desc.info = req->info;
	desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;

	err = crypt(&desc, req->dst, req->src, req->nbytes);

	req->base.complete = rctx->complete;

out:
	local_bh_disable();
	rctx->complete(&req->base, err);
	local_bh_enable();
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 144 100.00% 2 100.00%
Total 144 100.00% 2 100.00%



static void cryptd_blkcipher_encrypt(struct crypto_async_request *req, int err)
{
	struct cryptd_blkcipher_ctx *ctx = crypto_tfm_ctx(req->tfm);
	struct crypto_blkcipher *child = ctx->child;

	cryptd_blkcipher_crypt(ablkcipher_request_cast(req), child, err,
			       crypto_blkcipher_crt(child)->encrypt);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%



static void cryptd_blkcipher_decrypt(struct crypto_async_request *req, int err)
{
	struct cryptd_blkcipher_ctx *ctx = crypto_tfm_ctx(req->tfm);
	struct crypto_blkcipher *child = ctx->child;

	cryptd_blkcipher_crypt(ablkcipher_request_cast(req), child, err,
			       crypto_blkcipher_crt(child)->decrypt);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%



static int cryptd_blkcipher_enqueue(struct ablkcipher_request *req,
				    crypto_completion_t compl)
{
	struct cryptd_blkcipher_request_ctx *rctx = ablkcipher_request_ctx(req);
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct cryptd_queue *queue;

	queue = cryptd_get_queue(crypto_ablkcipher_tfm(tfm));
	rctx->complete = req->base.complete;
	req->base.complete = compl;

	return cryptd_enqueue_request(queue, &req->base);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 65 83.33% 2 50.00%
huang ying huang ying 11 14.10% 1 25.00%
mark d. rustad mark d. rustad 2 2.56% 1 25.00%
Total 78 100.00% 4 100.00%



static int cryptd_blkcipher_encrypt_enqueue(struct ablkcipher_request *req)
{
	return cryptd_blkcipher_enqueue(req, cryptd_blkcipher_encrypt);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static int cryptd_blkcipher_decrypt_enqueue(struct ablkcipher_request *req)
{
	return cryptd_blkcipher_enqueue(req, cryptd_blkcipher_decrypt);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static int cryptd_blkcipher_init_tfm(struct crypto_tfm *tfm)
{
	struct crypto_instance *inst = crypto_tfm_alg_instance(tfm);
	struct cryptd_instance_ctx *ictx = crypto_instance_ctx(inst);
	struct crypto_spawn *spawn = &ictx->spawn;
	struct cryptd_blkcipher_ctx *ctx = crypto_tfm_ctx(tfm);
	struct crypto_blkcipher *cipher;

	cipher = crypto_spawn_blkcipher(spawn);
	if (IS_ERR(cipher))
		return PTR_ERR(cipher);

	ctx->child = cipher;
	tfm->crt_ablkcipher.reqsize =
		sizeof(struct cryptd_blkcipher_request_ctx);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 97 100.00% 1 100.00%
Total 97 100.00% 1 100.00%



static void cryptd_blkcipher_exit_tfm(struct crypto_tfm *tfm)
{
	struct cryptd_blkcipher_ctx *ctx = crypto_tfm_ctx(tfm);

	crypto_free_blkcipher(ctx->child);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%



static int cryptd_init_instance(struct crypto_instance *inst,
				struct crypto_alg *alg)
{
	if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME,
		     "cryptd(%s)",
		     alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
		return -ENAMETOOLONG;

	memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);

	inst->alg.cra_priority = alg->cra_priority + 50;
	inst->alg.cra_blocksize = alg->cra_blocksize;
	inst->alg.cra_alignmask = alg->cra_alignmask;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 91 100.00% 1 100.00%
Total 91 100.00% 1 100.00%



static void *cryptd_alloc_instance(struct crypto_alg *alg, unsigned int head,
				   unsigned int tail)
{
	char *p;
	struct crypto_instance *inst;
	int err;

	p = kzalloc(head + sizeof(*inst) + tail, GFP_KERNEL);
	if (!p)
		return ERR_PTR(-ENOMEM);

	inst = (void *)(p + head);

	err = cryptd_init_instance(inst, alg);
	if (err)
		goto out_free_inst;

out:
	return p;

out_free_inst:
	kfree(p);
	p = ERR_PTR(err);
	goto out;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 104 93.69% 4 80.00%
julia lawall julia lawall 7 6.31% 1 20.00%
Total 111 100.00% 5 100.00%



static int cryptd_create_blkcipher(struct crypto_template *tmpl,
				   struct rtattr **tb,
				   struct cryptd_queue *queue)
{
	struct cryptd_instance_ctx *ctx;
	struct crypto_instance *inst;
	struct crypto_alg *alg;
	u32 type = CRYPTO_ALG_TYPE_BLKCIPHER;
	u32 mask = CRYPTO_ALG_TYPE_MASK;
	int err;

	cryptd_check_internal(tb, &type, &mask);

	alg = crypto_get_attr_alg(tb, type, mask);
	if (IS_ERR(alg))
		return PTR_ERR(alg);

	inst = cryptd_alloc_instance(alg, 0, sizeof(*ctx));
	err = PTR_ERR(inst);
	if (IS_ERR(inst))
		goto out_put_alg;

	ctx = crypto_instance_ctx(inst);
	ctx->queue = queue;

	err = crypto_init_spawn(&ctx->spawn, alg, inst,
				CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);
	if (err)
		goto out_free_inst;

	type = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC;
	if (alg->cra_flags & CRYPTO_ALG_INTERNAL)
		type |= CRYPTO_ALG_INTERNAL;
	inst->alg.cra_flags = type;
	inst->alg.cra_type = &crypto_ablkcipher_type;

	inst->alg.cra_ablkcipher.ivsize = alg->cra_blkcipher.ivsize;
	inst->alg.cra_ablkcipher.min_keysize = alg->cra_blkcipher.min_keysize;
	inst->alg.cra_ablkcipher.max_keysize = alg->cra_blkcipher.max_keysize;

	inst->alg.cra_ablkcipher.geniv = alg->cra_blkcipher.geniv;

	inst->alg.cra_ctxsize = sizeof(struct cryptd_blkcipher_ctx);

	inst->alg.cra_init = cryptd_blkcipher_init_tfm;
	inst->alg.cra_exit = cryptd_blkcipher_exit_tfm;

	inst->alg.cra_ablkcipher.setkey = cryptd_blkcipher_setkey;
	inst->alg.cra_ablkcipher.encrypt = cryptd_blkcipher_encrypt_enqueue;
	inst->alg.cra_ablkcipher.decrypt = cryptd_blkcipher_decrypt_enqueue;

	err = crypto_register_instance(tmpl, inst);
	if (err) {
		crypto_drop_spawn(&ctx->spawn);
out_free_inst:
		kfree(inst);
	}

out_put_alg:
	crypto_mod_put(alg);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 293 85.17% 5 62.50%
stephan mueller stephan mueller 42 12.21% 1 12.50%
steffen klassert steffen klassert 7 2.03% 1 12.50%
huang ying huang ying 2 0.58% 1 12.50%
Total 344 100.00% 8 100.00%



static int cryptd_hash_init_tfm(struct crypto_tfm *tfm)
{
	struct crypto_instance *inst = crypto_tfm_alg_instance(tfm);
	struct hashd_instance_ctx *ictx = crypto_instance_ctx(inst);
	struct crypto_shash_spawn *spawn = &ictx->spawn;
	struct cryptd_hash_ctx *ctx = crypto_tfm_ctx(tfm);
	struct crypto_shash *hash;

	hash = crypto_spawn_shash(spawn);
	if (IS_ERR(hash))
		return PTR_ERR(hash);

	ctx->child = hash;
	crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
				 sizeof(struct cryptd_hash_request_ctx) +
				 crypto_shash_descsize(hash));
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 58 55.77% 1 25.00%
herbert xu herbert xu 46 44.23% 3 75.00%
Total 104 100.00% 4 100.00%



static void cryptd_hash_exit_tfm(struct crypto_tfm *tfm)
{
	struct cryptd_hash_ctx *ctx = crypto_tfm_ctx(tfm);

	crypto_free_shash(ctx->child);
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 20 71.43% 1 33.33%
huang ying huang ying 7 25.00% 1 33.33%
herbert xu herbert xu 1 3.57% 1 33.33%
Total 28 100.00% 3 100.00%



static int cryptd_hash_setkey(struct crypto_ahash *parent,
				   const u8 *key, unsigned int keylen)
{
	struct cryptd_hash_ctx *ctx   = crypto_ahash_ctx(parent);
	struct crypto_shash *child = ctx->child;
	int err;

	crypto_shash_clear_flags(child, CRYPTO_TFM_REQ_MASK);
	crypto_shash_set_flags(child, crypto_ahash_get_flags(parent) &
				      CRYPTO_TFM_REQ_MASK);
	err = crypto_shash_setkey(child, key, keylen);
	crypto_ahash_set_flags(parent, crypto_shash_get_flags(child) &
				       CRYPTO_TFM_RES_MASK);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 81 93.10% 1 33.33%
herbert xu herbert xu 6 6.90% 2 66.67%
Total 87 100.00% 3 100.00%



static int cryptd_hash_enqueue(struct ahash_request *req,
				crypto_completion_t compl)
{
	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);
	struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
	struct cryptd_queue *queue =
		cryptd_get_queue(crypto_ahash_tfm(tfm));

	rctx->complete = req->base.complete;
	req->base.complete = compl;

	return cryptd_enqueue_request(queue, &req->base);
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 67 88.16% 1 33.33%
huang ying huang ying 7 9.21% 1 33.33%
mark d. rustad mark d. rustad 2 2.63% 1 33.33%
Total 76 100.00% 3 100.00%



static void cryptd_hash_init(struct crypto_async_request *req_async, int err)
{
	struct cryptd_hash_ctx *ctx = crypto_tfm_ctx(req_async->tfm);
	struct crypto_shash *child = ctx->child;
	struct ahash_request *req = ahash_request_cast(req_async);
	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);
	struct shash_desc *desc = &rctx->desc;

	if (unlikely(err == -EINPROGRESS))
		goto out;

	desc->tfm = child;
	desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;

	err = crypto_shash_init(desc);

	req->base.complete = rctx->complete;

out:
	local_bh_disable();
	rctx->complete(&req->base, err);
	local_bh_enable();
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 111 87.40% 1 50.00%
herbert xu herbert xu 16 12.60% 1 50.00%
Total 127 100.00% 2 100.00%



static int cryptd_hash_init_enqueue(struct ahash_request *req)
{
	return cryptd_hash_enqueue(req, cryptd_hash_init);
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static void cryptd_hash_update(struct crypto_async_request *req_async, int err)
{
	struct ahash_request *req = ahash_request_cast(req_async);
	struct cryptd_hash_request_ctx *rctx;

	rctx = ahash_request_ctx(req);

	if (unlikely(err == -EINPROGRESS))
		goto out;

	err = shash_ahash_update(req, &rctx->desc);

	req->base.complete = rctx->complete;

out:
	local_bh_disable();
	rctx->complete(&req->base, err);
	local_bh_enable();
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 87 95.60% 1 50.00%
herbert xu herbert xu 4 4.40% 1 50.00%
Total 91 100.00% 2 100.00%



static int cryptd_hash_update_enqueue(struct ahash_request *req)
{
	return cryptd_hash_enqueue(req, cryptd_hash_update);
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static void cryptd_hash_final(struct crypto_async_request *req_async, int err)
{
	struct ahash_request *req = ahash_request_cast(req_async);
	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);

	if (unlikely(err == -EINPROGRESS))
		goto out;

	err = crypto_shash_final(&rctx->desc, req->result);

	req->base.complete = rctx->complete;

out:
	local_bh_disable();
	rctx->complete(&req->base, err);
	local_bh_enable();
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 86 94.51% 1 50.00%
herbert xu herbert xu 5 5.49% 1 50.00%
Total 91 100.00% 2 100.00%



static int cryptd_hash_final_enqueue(struct ahash_request *req)
{
	return cryptd_hash_enqueue(req, cryptd_hash_final);
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static void cryptd_hash_finup(struct crypto_async_request *req_async, int err)
{
	struct ahash_request *req = ahash_request_cast(req_async);
	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);

	if (unlikely(err == -EINPROGRESS))
		goto out;

	err = shash_ahash_finup(req, &rctx->desc);

	req->base.complete = rctx->complete;

out:
	local_bh_disable();
	rctx->complete(&req->base, err);
	local_bh_enable();
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 89 100.00% 1 100.00%
Total 89 100.00% 1 100.00%



static int cryptd_hash_finup_enqueue(struct ahash_request *req)
{
	return cryptd_hash_enqueue(req, cryptd_hash_finup);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static void cryptd_hash_digest(struct crypto_async_request *req_async, int err)
{
	struct cryptd_hash_ctx *ctx = crypto_tfm_ctx(req_async->tfm);
	struct crypto_shash *child = ctx->child;
	struct ahash_request *req = ahash_request_cast(req_async);
	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);
	struct shash_desc *desc = &rctx->desc;

	if (unlikely(err == -EINPROGRESS))
		goto out;

	desc->tfm = child;
	desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;

	err = shash_ahash_digest(req, desc);

	req->base.complete = rctx->complete;

out:
	local_bh_disable();
	rctx->complete(&req->base, err);
	local_bh_enable();
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 112 86.82% 1 50.00%
herbert xu herbert xu 17 13.18% 1 50.00%
Total 129 100.00% 2 100.00%



static int cryptd_hash_digest_enqueue(struct ahash_request *req)
{
	return cryptd_hash_enqueue(req, cryptd_hash_digest);
}

Contributors
Person Tokens Prop Commits CommitProp
loc ho loc ho 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static int cryptd_hash_export(struct ahash_request *req, void *out)
{
	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);

	return crypto_shash_export(&rctx->desc, out);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%



static int cryptd_hash_import(struct ahash_request *req, const void *in)
{
	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);

	return crypto_shash_import(&rctx->desc, in);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%



static int cryptd_create_hash(struct crypto_template *tmpl, struct rtattr **tb,
			      struct cryptd_queue *queue)
{
	struct hashd_instance_ctx *ctx;
	struct ahash_instance *inst;
	struct shash_alg *salg;
	struct crypto_alg *alg;
	u32 type = 0;
	u32 mask = 0;
	int err;

	cryptd_check_internal(tb, &type, &mask);

	salg = shash_attr_alg(tb[1], type, mask);
	if (IS_ERR(salg))
		return PTR_ERR(salg);

	alg = &salg->base;
	inst = cryptd_alloc_instance(alg, ahash_instance_headroom(),
				     sizeof(*ctx));
	err = PTR_ERR(inst);
	if (IS_ERR(inst))
		goto out_put_alg;

	ctx = ahash_instance_ctx(inst);
	ctx->queue = queue;

	err = crypto_init_shash_spawn(&ctx->spawn, salg,
				      ahash_crypto_instance(inst));
	if (err)
		goto out_free_inst;

	type = CRYPTO_ALG_ASYNC;
	if (alg->cra_flags & CRYPTO_ALG_INTERNAL)
		type |= CRYPTO_ALG_INTERNAL;
	inst->alg.halg.base.cra_flags = type;

	inst->alg.halg.digestsize = salg->digestsize;
	inst->alg.halg.statesize = salg->statesize;
	inst->alg.halg.base.cra_ctxsize = sizeof(struct cryptd_hash_ctx);

	inst->alg.halg.base.cra_init = cryptd_hash_init_tfm;
	inst->alg.halg.base.cra_exit = cryptd_hash_exit_tfm;

	inst->alg.init   = cryptd_hash_init_enqueue;
	inst->alg.update = cryptd_hash_update_enqueue;
	inst->alg.final  = cryptd_hash_final_enqueue;
	inst->alg.finup  = cryptd_hash_finup_enqueue;
	inst->alg.export = cryptd_hash_export;
	inst->alg.import = cryptd_hash_import;
	inst->alg.setkey = cryptd_hash_setkey;
	inst->alg.digest = cryptd_hash_digest_enqueue;

	err = ahash_register_instance(tmpl, inst);
	if (err) {
		crypto_drop_shash(&ctx->spawn);
out_free_inst:
		kfree(inst);
	}

out_put_alg:
	crypto_mod_put(alg);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 159 43.44% 4 44.44%
loc ho loc ho 146 39.89% 1 11.11%
stephan mueller stephan mueller 40 10.93% 1 11.11%
rui wang rui wang 12 3.28% 1 11.11%
steffen klassert steffen klassert 7 1.91% 1 11.11%
huang ying huang ying 2 0.55% 1 11.11%
Total 366 100.00% 9 100.00%



static int cryptd_aead_setkey(struct crypto_aead *parent,
			      const u8 *key, unsigned int keylen)
{
	struct cryptd_aead_ctx *ctx = crypto_aead_ctx(parent);
	struct crypto_aead *child = ctx->child;

	return crypto_aead_setkey(child, key, keylen);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 49 100.00% 1 100.00%
Total 49 100.00% 1 100.00%



static int cryptd_aead_setauthsize(struct crypto_aead *parent,
				   unsigned int authsize)
{
	struct cryptd_aead_ctx *ctx = crypto_aead_ctx(parent);
	struct crypto_aead *child = ctx->child;

	return crypto_aead_setauthsize(child, authsize);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%



static void cryptd_aead_crypt(struct aead_request *req,
			struct crypto_aead *child,
			int err,
			int (*crypt)(struct aead_request *req))
{
	struct cryptd_aead_request_ctx *rctx;
	crypto_completion_t compl;

	rctx = aead_request_ctx(req);
	compl = rctx->complete;

	if (unlikely(err == -EINPROGRESS))
		goto out;
	aead_request_set_tfm(req, child);
	err = crypt( req );
out:
	local_bh_disable();
	compl(&req->base, err);
	local_bh_enable();
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 58 59.79% 1 20.00%
loc ho loc ho 24 24.74% 1 20.00%
herbert xu herbert xu 15 15.46% 3 60.00%
Total 97 100.00% 5 100.00%



static void cryptd_aead_encrypt(struct crypto_async_request *areq, int err)
{
	struct cryptd_aead_ctx *ctx = crypto_tfm_ctx(areq->tfm);
	struct crypto_aead *child = ctx->child;
	struct aead_request *req;

	req = container_of(areq, struct aead_request, base);
	cryptd_aead_crypt(req, child, err, crypto_aead_alg(child)->encrypt);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 39 57.35% 1 25.00%
herbert xu herbert xu 29 42.65% 3 75.00%
Total 68 100.00% 4 100.00%



static void cryptd_aead_decrypt(struct crypto_async_request *areq, int err)
{
	struct cryptd_aead_ctx *ctx = crypto_tfm_ctx(areq->tfm);
	struct crypto_aead *child = ctx->child;
	struct aead_request *req;

	req = container_of(areq, struct aead_request, base);
	cryptd_aead_crypt(req, child, err, crypto_aead_alg(child)->decrypt);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 65 95.59% 1 33.33%
herbert xu herbert xu 3 4.41% 2 66.67%
Total 68 100.00% 3 100.00%



static int cryptd_aead_enqueue(struct aead_request *req,
				    crypto_completion_t compl)
{
	struct cryptd_aead_request_ctx *rctx = aead_request_ctx(req);
	struct crypto_aead *tfm = crypto_aead_reqtfm(req);
	struct cryptd_queue *queue = cryptd_get_queue(crypto_aead_tfm(tfm));

	rctx->complete = req->base.complete;
	req->base.complete = compl;
	return cryptd_enqueue_request(queue, &req->base);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 74 97.37% 1 50.00%
mark d. rustad mark d. rustad 2 2.63% 1 50.00%
Total 76 100.00% 2 100.00%



static int cryptd_aead_encrypt_enqueue(struct aead_request *req)
{
	return cryptd_aead_enqueue(req, cryptd_aead_encrypt );
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static int cryptd_aead_decrypt_enqueue(struct aead_request *req)
{
	return cryptd_aead_enqueue(req, cryptd_aead_decrypt );
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static int cryptd_aead_init_tfm(struct crypto_aead *tfm)
{
	struct aead_instance *inst = aead_alg_instance(tfm);
	struct aead_instance_ctx *ictx = aead_instance_ctx(inst);
	struct crypto_aead_spawn *spawn = &ictx->aead_spawn;
	struct cryptd_aead_ctx *ctx = crypto_aead_ctx(tfm);
	struct crypto_aead *cipher;

	cipher = crypto_spawn_aead(spawn);
	if (IS_ERR(cipher))
		return PTR_ERR(cipher);

	ctx->child = cipher;
	crypto_aead_set_reqsize(
		tfm, max((unsigned)sizeof(struct cryptd_aead_request_ctx),
			 crypto_aead_reqsize(cipher)));
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 87 81.31% 1 25.00%
herbert xu herbert xu 20 18.69% 3 75.00%
Total 107 100.00% 4 100.00%



static void cryptd_aead_exit_tfm(struct crypto_aead *tfm)
{
	struct cryptd_aead_ctx *ctx = crypto_aead_ctx(tfm);
	crypto_free_aead(ctx->child);
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 26 92.86% 1 50.00%
herbert xu herbert xu 2 7.14% 1 50.00%
Total 28 100.00% 2 100.00%



static int cryptd_create_aead(struct crypto_template *tmpl,
		              struct rtattr **tb,
			      struct cryptd_queue *queue)
{
	struct aead_instance_ctx *ctx;
	struct aead_instance *inst;
	struct aead_alg *alg;
	const char *name;
	u32 type = 0;
	u32 mask = CRYPTO_ALG_ASYNC;
	int err;

	cryptd_check_internal(tb, &type, &mask);

	name = crypto_attr_alg_name(tb[1]);
	if (IS_ERR(name))
		return PTR_ERR(name);

	inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
	if (!inst)
		return -ENOMEM;

	ctx = aead_instance_ctx(inst);
	ctx->queue = queue;

	crypto_set_aead_spawn(&ctx->aead_spawn, aead_crypto_instance(inst));
	err = crypto_grab_aead(&ctx->aead_spawn, name, type, mask);
	if (err)
		goto out_free_inst;

	alg = crypto_spawn_aead_alg(&ctx->aead_spawn);
	err = cryptd_init_instance(aead_crypto_instance(inst), &alg->base);
	if (err)
		goto out_drop_aead;

	inst->alg.base.cra_flags = CRYPTO_ALG_ASYNC |
				   (alg->base.cra_flags & CRYPTO_ALG_INTERNAL);
	inst->alg.base.cra_ctxsize = sizeof(struct cryptd_aead_ctx);

	inst->alg.ivsize = crypto_aead_alg_ivsize(alg);
	inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg);

	inst->alg.init = cryptd_aead_init_tfm;
	inst->alg.exit = cryptd_aead_exit_tfm;
	inst->alg.setkey = cryptd_aead_setkey;
	inst->alg.setauthsize = cryptd_aead_setauthsize;
	inst->alg.encrypt = cryptd_aead_encrypt_enqueue;
	inst->alg.decrypt = cryptd_aead_decrypt_enqueue;

	err = aead_register_instance(tmpl, inst);
	if (err) {
out_drop_aead:
		crypto_drop_aead(&ctx->aead_spawn);
out_free_inst:
		kfree(inst);
	}
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 195 57.86% 1 16.67%
herbert xu herbert xu 115 34.12% 4 66.67%
stephan mueller stephan mueller 27 8.01% 1 16.67%
Total 337 100.00% 6 100.00%


static struct cryptd_queue queue;



static int cryptd_create(struct crypto_template *tmpl, struct rtattr **tb)
{
	struct crypto_attr_type *algt;

	algt = crypto_get_attr_type(tb);
	if (IS_ERR(algt))
		return PTR_ERR(algt);

	switch (algt->type & algt->mask & CRYPTO_ALG_TYPE_MASK) {
	case CRYPTO_ALG_TYPE_BLKCIPHER:
		return cryptd_create_blkcipher(tmpl, tb, &queue);
	case CRYPTO_ALG_TYPE_DIGEST:
		return cryptd_create_hash(tmpl, tb, &queue);
	case CRYPTO_ALG_TYPE_AEAD:
		return cryptd_create_aead(tmpl, tb, &queue);
	}

	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 102 100.00% 1 100.00%
Total 102 100.00% 1 100.00%



static void cryptd_free(struct crypto_instance *inst)
{
	struct cryptd_instance_ctx *ctx = crypto_instance_ctx(inst);
	struct hashd_instance_ctx *hctx = crypto_instance_ctx(inst);
	struct aead_instance_ctx *aead_ctx = crypto_instance_ctx(inst);

	switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) {
	case CRYPTO_ALG_TYPE_AHASH:
		crypto_drop_shash(&hctx->spawn);
		kfree(ahash_instance(inst));
		return;
	case CRYPTO_ALG_TYPE_AEAD:
		crypto_drop_aead(&aead_ctx->aead_spawn);
		kfree(aead_instance(inst));
		return;
	default:
		crypto_drop_spawn(&ctx->spawn);
		kfree(inst);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 103 96.26% 1 50.00%
herbert xu herbert xu 4 3.74% 1 50.00%
Total 107 100.00% 2 100.00%


static struct crypto_template cryptd_tmpl = {
	.name = "cryptd",
	.create = cryptd_create,
	.free = cryptd_free,
	.module = THIS_MODULE,
};



struct cryptd_ablkcipher *cryptd_alloc_ablkcipher(const char *alg_name,
						  u32 type, u32 mask)
{
	char cryptd_alg_name[CRYPTO_MAX_ALG_NAME];
	struct crypto_tfm *tfm;

	if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME,
		     "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME)
		return ERR_PTR(-EINVAL);
	type = crypto_skcipher_type(type);
	mask &= ~CRYPTO_ALG_TYPE_MASK;
	mask |= (CRYPTO_ALG_GENIV | CRYPTO_ALG_TYPE_BLKCIPHER_MASK);
	tfm = crypto_alloc_base(cryptd_alg_name, type, mask);
	if (IS_ERR(tfm))
		return ERR_CAST(tfm);
	if (tfm->__crt_alg->cra_module != THIS_MODULE) {
		crypto_free_tfm(tfm);
		return ERR_PTR(-EINVAL);
	}

	return __cryptd_ablkcipher_cast(__crypto_ablkcipher_cast(tfm));
}
Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 124 96.88% 2 66.67%
alexander kuleshov alexander kuleshov 4 3.12% 1 33.33%
Total 128 100.00% 3 100.00%


EXPORT_SYMBOL_GPL(cryptd_alloc_ablkcipher);



struct crypto_blkcipher *cryptd_ablkcipher_child(struct cryptd_ablkcipher *tfm)
{
	struct cryptd_blkcipher_ctx *ctx = crypto_ablkcipher_ctx(&tfm->base);
	return ctx->child;
}
Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_ablkcipher_child);



void cryptd_free_ablkcipher(struct cryptd_ablkcipher *tfm)
{
	crypto_free_ablkcipher(&tfm->base);
}
Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_free_ablkcipher);



struct cryptd_ahash *cryptd_alloc_ahash(const char *alg_name,
					u32 type, u32 mask)
{
	char cryptd_alg_name[CRYPTO_MAX_ALG_NAME];
	struct crypto_ahash *tfm;

	if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME,
		     "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME)
		return ERR_PTR(-EINVAL);
	tfm = crypto_alloc_ahash(cryptd_alg_name, type, mask);
	if (IS_ERR(tfm))
		return ERR_CAST(tfm);
	if (tfm->base.__crt_alg->cra_module != THIS_MODULE) {
		crypto_free_ahash(tfm);
		return ERR_PTR(-EINVAL);
	}

	return __cryptd_ahash_cast(tfm);
}
Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 107 100.00% 1 100.00%
Total 107 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_alloc_ahash);



struct crypto_shash *cryptd_ahash_child(struct cryptd_ahash *tfm)
{
	struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(&tfm->base);

	return ctx->child;
}
Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_ahash_child);



struct shash_desc *cryptd_shash_desc(struct ahash_request *req)
{
	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);
	return &rctx->desc;
}
Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_shash_desc);



void cryptd_free_ahash(struct cryptd_ahash *tfm)
{
	crypto_free_ahash(&tfm->base);
}
Contributors
Person Tokens Prop Commits CommitProp
huang ying huang ying 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_free_ahash);



struct cryptd_aead *cryptd_alloc_aead(const char *alg_name,
						  u32 type, u32 mask)
{
	char cryptd_alg_name[CRYPTO_MAX_ALG_NAME];
	struct crypto_aead *tfm;

	if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME,
		     "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME)
		return ERR_PTR(-EINVAL);
	tfm = crypto_alloc_aead(cryptd_alg_name, type, mask);
	if (IS_ERR(tfm))
		return ERR_CAST(tfm);
	if (tfm->base.__crt_alg->cra_module != THIS_MODULE) {
		crypto_free_aead(tfm);
		return ERR_PTR(-EINVAL);
	}
	return __cryptd_aead_cast(tfm);
}
Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 107 100.00% 1 100.00%
Total 107 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_alloc_aead);



struct crypto_aead *cryptd_aead_child(struct cryptd_aead *tfm)
{
	struct cryptd_aead_ctx *ctx;
	ctx = crypto_aead_ctx(&tfm->base);
	return ctx->child;
}
Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_aead_child);



void cryptd_free_aead(struct cryptd_aead *tfm)
{
	crypto_free_aead(&tfm->base);
}
Contributors
Person Tokens Prop Commits CommitProp
adrian hoban adrian hoban 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cryptd_free_aead);



static int __init cryptd_init(void)
{
	int err;

	err = cryptd_init_queue(&queue, CRYPTD_MAX_CPU_QLEN);
	if (err)
		return err;

	err = crypto_register_template(&cryptd_tmpl);
	if (err)
		cryptd_fini_queue(&queue);

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 44 88.00% 1 50.00%
huang ying huang ying 6 12.00% 1 50.00%
Total 50 100.00% 2 100.00%



static void __exit cryptd_exit(void)
{
	cryptd_fini_queue(&queue);
	crypto_unregister_template(&cryptd_tmpl);
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 19 90.48% 1 50.00%
huang ying huang ying 2 9.52% 1 50.00%
Total 21 100.00% 2 100.00%


subsys_initcall(cryptd_init);

module_exit(cryptd_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Software async crypto daemon");
MODULE_ALIAS_CRYPTO("cryptd");
Overall Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 2005 40.97% 18 51.43%
adrian hoban adrian hoban 1007 20.58% 1 2.86%
loc ho loc ho 885 18.08% 1 2.86%
huang ying huang ying 777 15.88% 5 14.29%
stephan mueller stephan mueller 163 3.33% 1 2.86%
steffen klassert steffen klassert 14 0.29% 1 2.86%
rui wang rui wang 12 0.25% 1 2.86%
julia lawall julia lawall 7 0.14% 1 2.86%
jussi kivilinna jussi kivilinna 7 0.14% 1 2.86%
mark d. rustad mark d. rustad 6 0.12% 1 2.86%
kees cook kees cook 5 0.10% 1 2.86%
alexander kuleshov alexander kuleshov 4 0.08% 1 2.86%
tejun heo tejun heo 1 0.02% 1 2.86%
christoph lameter christoph lameter 1 0.02% 1 2.86%
Total 4894 100.00% 35 100.00%
  Directory: crypto

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
huang ying	huang ying	84	100.00%	1	100.00%
	Total	84	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 crypto/cryptd.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
