[linux.git] / crypto / algapi.c

/*
 * Cryptographic API for algorithms (i.e., low-level API).
 *
 * Copyright (c) 2006 Herbert Xu <[email protected]>
 *
 * 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 <linux/err.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/rtnetlink.h>
#include <linux/string.h>

#include "internal.h"

static void crypto_remove_final(struct list_head *list);

static LIST_HEAD(crypto_template_list);

void crypto_larval_error(const char *name, u32 type, u32 mask)
{
	struct crypto_alg *alg;

	alg = crypto_alg_lookup(name, type, mask);

	if (alg) {
		if (crypto_is_larval(alg)) {
			struct crypto_larval *larval = (void *)alg;
			complete_all(&larval->completion);
		}
		crypto_mod_put(alg);
	}
}
EXPORT_SYMBOL_GPL(crypto_larval_error);

static inline int crypto_set_driver_name(struct crypto_alg *alg)
{
	static const char suffix[] = "-generic";
	char *driver_name = alg->cra_driver_name;
	int len;

	if (*driver_name)
		return 0;

	len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
	if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)
		return -ENAMETOOLONG;

	memcpy(driver_name + len, suffix, sizeof(suffix));
	return 0;
}

static int crypto_check_alg(struct crypto_alg *alg)
{
	if (alg->cra_alignmask & (alg->cra_alignmask + 1))
		return -EINVAL;

	if (alg->cra_blocksize > PAGE_SIZE / 8)
		return -EINVAL;

	if (alg->cra_priority < 0)
		return -EINVAL;

	return crypto_set_driver_name(alg);
}

static void crypto_destroy_instance(struct crypto_alg *alg)
{
	struct crypto_instance *inst = (void *)alg;
	struct crypto_template *tmpl = inst->tmpl;

	tmpl->free(inst);
	crypto_tmpl_put(tmpl);
}

static void crypto_remove_spawn(struct crypto_spawn *spawn,
				struct list_head *list,
				struct list_head *secondary_spawns)
{
	struct crypto_instance *inst = spawn->inst;
	struct crypto_template *tmpl = inst->tmpl;

	list_del_init(&spawn->list);
	spawn->alg = NULL;

	if (crypto_is_dead(&inst->alg))
		return;

	inst->alg.cra_flags |= CRYPTO_ALG_DEAD;
	if (hlist_unhashed(&inst->list))
		return;

	if (!tmpl || !crypto_tmpl_get(tmpl))
		return;

	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg);
	list_move(&inst->alg.cra_list, list);
	hlist_del(&inst->list);
	inst->alg.cra_destroy = crypto_destroy_instance;

	list_splice(&inst->alg.cra_users, secondary_spawns);
}

static void crypto_remove_spawns(struct list_head *spawns,
				 struct list_head *list, u32 new_type)
{
	struct crypto_spawn *spawn, *n;
	LIST_HEAD(secondary_spawns);

	list_for_each_entry_safe(spawn, n, spawns, list) {
		if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)
			continue;

		crypto_remove_spawn(spawn, list, &secondary_spawns);
	}

	while (!list_empty(&secondary_spawns)) {
		list_for_each_entry_safe(spawn, n, &secondary_spawns, list)
			crypto_remove_spawn(spawn, list, &secondary_spawns);
	}
}

static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg)
{
	struct crypto_alg *q;
	struct crypto_larval *larval;
	int ret = -EAGAIN;

	if (crypto_is_dead(alg))
		goto err;

	INIT_LIST_HEAD(&alg->cra_users);

	/* No cheating! */
	alg->cra_flags &= ~CRYPTO_ALG_TESTED;

	ret = -EEXIST;

	atomic_set(&alg->cra_refcnt, 1);
	list_for_each_entry(q, &crypto_alg_list, cra_list) {
		if (q == alg)
			goto err;

		if (crypto_is_larval(q)) {
			if (!strcmp(alg->cra_driver_name, q->cra_driver_name))
				goto err;
			continue;
		}

		if (!strcmp(q->cra_driver_name, alg->cra_name) ||
		    !strcmp(q->cra_name, alg->cra_driver_name))
			goto err;
	}

	larval = crypto_larval_alloc(alg->cra_name,
				     alg->cra_flags | CRYPTO_ALG_TESTED, 0);
	if (IS_ERR(larval))
		goto out;

	ret = -ENOENT;
	larval->adult = crypto_mod_get(alg);
	if (!larval->adult)
		goto free_larval;

	atomic_set(&larval->alg.cra_refcnt, 1);
	memcpy(larval->alg.cra_driver_name, alg->cra_driver_name,
	       CRYPTO_MAX_ALG_NAME);
	larval->alg.cra_priority = alg->cra_priority;

	list_add(&alg->cra_list, &crypto_alg_list);
	list_add(&larval->alg.cra_list, &crypto_alg_list);

out:	
	return larval;

free_larval:
	kfree(larval);
err:
	larval = ERR_PTR(ret);
	goto out;
}

void crypto_alg_tested(const char *name, int err)
{
	struct crypto_larval *test;
	struct crypto_alg *alg;
	struct crypto_alg *q;
	LIST_HEAD(list);

	down_write(&crypto_alg_sem);
	list_for_each_entry(q, &crypto_alg_list, cra_list) {
		if (!crypto_is_larval(q))
			continue;

		test = (struct crypto_larval *)q;

		if (!strcmp(q->cra_driver_name, name))
			goto found;
	}

	printk(KERN_ERR "alg: Unexpected test result for %s: %d\n", name, err);
	goto unlock;

found:
	alg = test->adult;
	if (err || list_empty(&alg->cra_list))
		goto complete;

	alg->cra_flags |= CRYPTO_ALG_TESTED;

	list_for_each_entry(q, &crypto_alg_list, cra_list) {
		if (q == alg)
			continue;

		if (crypto_is_moribund(q))
			continue;

		if (crypto_is_larval(q)) {
			struct crypto_larval *larval = (void *)q;

			/*
			 * Check to see if either our generic name or
			 * specific name can satisfy the name requested
			 * by the larval entry q.
			 */
			if (strcmp(alg->cra_name, q->cra_name) &&
			    strcmp(alg->cra_driver_name, q->cra_name))
				continue;

			if (larval->adult)
				continue;
			if ((q->cra_flags ^ alg->cra_flags) & larval->mask)
				continue;
			if (!crypto_mod_get(alg))
				continue;

			larval->adult = alg;
			complete_all(&larval->completion);
			continue;
		}

		if (strcmp(alg->cra_name, q->cra_name))
			continue;

		if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&
		    q->cra_priority > alg->cra_priority)
			continue;

		crypto_remove_spawns(&q->cra_users, &list, alg->cra_flags);
	}

complete:
	complete_all(&test->completion);

unlock:
	up_write(&crypto_alg_sem);

	crypto_remove_final(&list);
}
EXPORT_SYMBOL_GPL(crypto_alg_tested);

static void crypto_remove_final(struct list_head *list)
{
	struct crypto_alg *alg;
	struct crypto_alg *n;

	list_for_each_entry_safe(alg, n, list, cra_list) {
		list_del_init(&alg->cra_list);
		crypto_alg_put(alg);
	}
}

static void crypto_wait_for_test(struct crypto_larval *larval)
{
	int err;

	err = crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, larval->adult);
	if (err != NOTIFY_STOP) {
		if (WARN_ON(err != NOTIFY_DONE))
			goto out;
		crypto_alg_tested(larval->alg.cra_driver_name, 0);
	}

	err = wait_for_completion_interruptible(&larval->completion);
	WARN_ON(err);

out:
	crypto_larval_kill(&larval->alg);
}

int crypto_register_alg(struct crypto_alg *alg)
{
	struct crypto_larval *larval;
	int err;

	err = crypto_check_alg(alg);
	if (err)
		return err;

	down_write(&crypto_alg_sem);
	larval = __crypto_register_alg(alg);
	up_write(&crypto_alg_sem);

	if (IS_ERR(larval))
		return PTR_ERR(larval);

	crypto_wait_for_test(larval);
	return 0;
}
EXPORT_SYMBOL_GPL(crypto_register_alg);

static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list)
{
	if (unlikely(list_empty(&alg->cra_list)))
		return -ENOENT;

	alg->cra_flags |= CRYPTO_ALG_DEAD;

	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg);
	list_del_init(&alg->cra_list);
	crypto_remove_spawns(&alg->cra_users, list, alg->cra_flags);

	return 0;
}

int crypto_unregister_alg(struct crypto_alg *alg)
{
	int ret;
	LIST_HEAD(list);
	
	down_write(&crypto_alg_sem);
	ret = crypto_remove_alg(alg, &list);
	up_write(&crypto_alg_sem);

	if (ret)
		return ret;

	BUG_ON(atomic_read(&alg->cra_refcnt) != 1);
	if (alg->cra_destroy)
		alg->cra_destroy(alg);

	crypto_remove_final(&list);
	return 0;
}
EXPORT_SYMBOL_GPL(crypto_unregister_alg);

int crypto_register_template(struct crypto_template *tmpl)
{
	struct crypto_template *q;
	int err = -EEXIST;

	down_write(&crypto_alg_sem);

	list_for_each_entry(q, &crypto_template_list, list) {
		if (q == tmpl)
			goto out;
	}

	list_add(&tmpl->list, &crypto_template_list);
	crypto_notify(CRYPTO_MSG_TMPL_REGISTER, tmpl);
	err = 0;
out:
	up_write(&crypto_alg_sem);
	return err;
}
EXPORT_SYMBOL_GPL(crypto_register_template);

void crypto_unregister_template(struct crypto_template *tmpl)
{
	struct crypto_instance *inst;
	struct hlist_node *p, *n;
	struct hlist_head *list;
	LIST_HEAD(users);

	down_write(&crypto_alg_sem);

	BUG_ON(list_empty(&tmpl->list));
	list_del_init(&tmpl->list);

	list = &tmpl->instances;
	hlist_for_each_entry(inst, p, list, list) {
		int err = crypto_remove_alg(&inst->alg, &users);
		BUG_ON(err);
	}

	crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl);

	up_write(&crypto_alg_sem);

	hlist_for_each_entry_safe(inst, p, n, list, list) {
		BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1);
		tmpl->free(inst);
	}
	crypto_remove_final(&users);
}
EXPORT_SYMBOL_GPL(crypto_unregister_template);

static struct crypto_template *__crypto_lookup_template(const char *name)
{
	struct crypto_template *q, *tmpl = NULL;

	down_read(&crypto_alg_sem);
	list_for_each_entry(q, &crypto_template_list, list) {
		if (strcmp(q->name, name))
			continue;
		if (unlikely(!crypto_tmpl_get(q)))
			continue;

		tmpl = q;
		break;
	}
	up_read(&crypto_alg_sem);

	return tmpl;
}

struct crypto_template *crypto_lookup_template(const char *name)
{
	return try_then_request_module(__crypto_lookup_template(name), name);
}
EXPORT_SYMBOL_GPL(crypto_lookup_template);

int crypto_register_instance(struct crypto_template *tmpl,
			     struct crypto_instance *inst)
{
	struct crypto_larval *larval;
	int err;

	err = crypto_check_alg(&inst->alg);
	if (err)
		goto err;

	inst->alg.cra_module = tmpl->module;

	down_write(&crypto_alg_sem);

	larval = __crypto_register_alg(&inst->alg);
	if (IS_ERR(larval))
		goto unlock;

	hlist_add_head(&inst->list, &tmpl->instances);
	inst->tmpl = tmpl;

unlock:
	up_write(&crypto_alg_sem);

	err = PTR_ERR(larval);
	if (IS_ERR(larval))
		goto err;

	crypto_wait_for_test(larval);
	err = 0;

err:
	return err;
}
EXPORT_SYMBOL_GPL(crypto_register_instance);

int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
		      struct crypto_instance *inst, u32 mask)
{
	int err = -EAGAIN;

	spawn->inst = inst;
	spawn->mask = mask;

	down_write(&crypto_alg_sem);
	if (!crypto_is_moribund(alg)) {
		list_add(&spawn->list, &alg->cra_users);
		spawn->alg = alg;
		err = 0;
	}
	up_write(&crypto_alg_sem);

	return err;
}
EXPORT_SYMBOL_GPL(crypto_init_spawn);

void crypto_drop_spawn(struct crypto_spawn *spawn)
{
	down_write(&crypto_alg_sem);
	list_del(&spawn->list);
	up_write(&crypto_alg_sem);
}
EXPORT_SYMBOL_GPL(crypto_drop_spawn);

struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
				    u32 mask)
{
	struct crypto_alg *alg;
	struct crypto_alg *alg2;
	struct crypto_tfm *tfm;

	down_read(&crypto_alg_sem);
	alg = spawn->alg;
	alg2 = alg;
	if (alg2)
		alg2 = crypto_mod_get(alg2);
	up_read(&crypto_alg_sem);

	if (!alg2) {
		if (alg)
			crypto_shoot_alg(alg);
		return ERR_PTR(-EAGAIN);
	}

	tfm = ERR_PTR(-EINVAL);
	if (unlikely((alg->cra_flags ^ type) & mask))
		goto out_put_alg;

	tfm = __crypto_alloc_tfm(alg, type, mask);
	if (IS_ERR(tfm))
		goto out_put_alg;

	return tfm;

out_put_alg:
	crypto_mod_put(alg);
	return tfm;
}
EXPORT_SYMBOL_GPL(crypto_spawn_tfm);

int crypto_register_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_register(&crypto_chain, nb);
}
EXPORT_SYMBOL_GPL(crypto_register_notifier);

int crypto_unregister_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_unregister(&crypto_chain, nb);
}
EXPORT_SYMBOL_GPL(crypto_unregister_notifier);

struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb)
{
	struct rtattr *rta = tb[0];
	struct crypto_attr_type *algt;

	if (!rta)
		return ERR_PTR(-ENOENT);
	if (RTA_PAYLOAD(rta) < sizeof(*algt))
		return ERR_PTR(-EINVAL);
	if (rta->rta_type != CRYPTOA_TYPE)
		return ERR_PTR(-EINVAL);

	algt = RTA_DATA(rta);

	return algt;
}
EXPORT_SYMBOL_GPL(crypto_get_attr_type);

int crypto_check_attr_type(struct rtattr **tb, u32 type)
{
	struct crypto_attr_type *algt;

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

	if ((algt->type ^ type) & algt->mask)
		return -EINVAL;

	return 0;
}
EXPORT_SYMBOL_GPL(crypto_check_attr_type);

const char *crypto_attr_alg_name(struct rtattr *rta)
{
	struct crypto_attr_alg *alga;

	if (!rta)
		return ERR_PTR(-ENOENT);
	if (RTA_PAYLOAD(rta) < sizeof(*alga))
		return ERR_PTR(-EINVAL);
	if (rta->rta_type != CRYPTOA_ALG)
		return ERR_PTR(-EINVAL);

	alga = RTA_DATA(rta);
	alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0;

	return alga->name;
}
EXPORT_SYMBOL_GPL(crypto_attr_alg_name);

struct crypto_alg *crypto_attr_alg(struct rtattr *rta, u32 type, u32 mask)
{
	const char *name;
	int err;

	name = crypto_attr_alg_name(rta);
	err = PTR_ERR(name);
	if (IS_ERR(name))
		return ERR_PTR(err);

	return crypto_alg_mod_lookup(name, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_attr_alg);

int crypto_attr_u32(struct rtattr *rta, u32 *num)
{
	struct crypto_attr_u32 *nu32;

	if (!rta)
		return -ENOENT;
	if (RTA_PAYLOAD(rta) < sizeof(*nu32))
		return -EINVAL;
	if (rta->rta_type != CRYPTOA_U32)
		return -EINVAL;

	nu32 = RTA_DATA(rta);
	*num = nu32->num;

	return 0;
}
EXPORT_SYMBOL_GPL(crypto_attr_u32);

struct crypto_instance *crypto_alloc_instance(const char *name,
					      struct crypto_alg *alg)
{
	struct crypto_instance *inst;
	struct crypto_spawn *spawn;
	int err;

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

	err = -ENAMETOOLONG;
	if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name,
		     alg->cra_name) >= CRYPTO_MAX_ALG_NAME)
		goto err_free_inst;

	if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)",
		     name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
		goto err_free_inst;

	spawn = crypto_instance_ctx(inst);
	err = crypto_init_spawn(spawn, alg, inst,
				CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);

	if (err)
		goto err_free_inst;

	return inst;

err_free_inst:
	kfree(inst);
	return ERR_PTR(err);
}
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 inline void crypto_inc_byte(u8 *a, unsigned int size)
{
	u8 *b = (a + size);
	u8 c;

	for (; size; size--) {
		c = *--b + 1;
		*b = c;
		if (c)
			break;
	}
}

void crypto_inc(u8 *a, unsigned int size)
{
	__be32 *b = (__be32 *)(a + size);
	u32 c;

	for (; size >= 4; size -= 4) {
		c = be32_to_cpu(*--b) + 1;
		*b = cpu_to_be32(c);
		if (c)
			return;
	}

	crypto_inc_byte(a, size);
}
EXPORT_SYMBOL_GPL(crypto_inc);

static inline void crypto_xor_byte(u8 *a, const u8 *b, unsigned int size)
{
	for (; size; size--)
		*a++ ^= *b++;
}

void crypto_xor(u8 *dst, const u8 *src, unsigned int size)
{
	u32 *a = (u32 *)dst;
	u32 *b = (u32 *)src;

	for (; size >= 4; size -= 4)
		*a++ ^= *b++;

	crypto_xor_byte((u8 *)a, (u8 *)b, size);
}
EXPORT_SYMBOL_GPL(crypto_xor);

static int __init crypto_algapi_init(void)
{
	crypto_init_proc();
	return 0;
}

static void __exit crypto_algapi_exit(void)
{
	crypto_exit_proc();
}

module_init(crypto_algapi_init);
module_exit(crypto_algapi_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Cryptographic algorithms API");
Commit	Line	Data
cce9e06d HX	1	/*
	2	* Cryptographic API for algorithms (i.e., low-level API).
	3	*
	4	* Copyright (c) 2006 Herbert Xu <[email protected]>
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the Free
	8	* Software Foundation; either version 2 of the License, or (at your option)
	9	* any later version.
	10	*
	11	*/
	12
6bfd4809	13	#include <linux/err.h>
cce9e06d HX	14	#include <linux/errno.h>
	15	#include <linux/init.h>
	16	#include <linux/kernel.h>
4cc7720c	17	#include <linux/list.h>
cce9e06d	18	#include <linux/module.h>
7fed0bf2	19	#include <linux/rtnetlink.h>
cce9e06d HX	20	#include <linux/string.h>
	21
	22	#include "internal.h"
	23
73d3864a HX	24	static void crypto_remove_final(struct list_head *list);
73d3864a HX	25
4cc7720c HX	26	static LIST_HEAD(crypto_template_list);
4cc7720c HX	27
492e2b63	28	void crypto_larval_error(const char *name, u32 type, u32 mask)
2825982d HX	29	{
	30	struct crypto_alg *alg;
	31
c51b6c81	32	alg = crypto_alg_lookup(name, type, mask);
2825982d HX	33
	34	if (alg) {
	35	if (crypto_is_larval(alg)) {
	36	struct crypto_larval larval = (void )alg;
fe3c5206	37	complete_all(&larval->completion);
2825982d HX	38	}
	39	crypto_mod_put(alg);
	40	}
	41	}
	42	EXPORT_SYMBOL_GPL(crypto_larval_error);
	43
cce9e06d HX	44	static inline int crypto_set_driver_name(struct crypto_alg *alg)
	45	{
	46	static const char suffix[] = "-generic";
	47	char *driver_name = alg->cra_driver_name;
	48	int len;
	49
	50	if (*driver_name)
	51	return 0;
	52
	53	len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
	54	if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)
	55	return -ENAMETOOLONG;
	56
	57	memcpy(driver_name + len, suffix, sizeof(suffix));
	58	return 0;
	59	}
	60
4cc7720c	61	static int crypto_check_alg(struct crypto_alg *alg)
cce9e06d	62	{
cce9e06d HX	63	if (alg->cra_alignmask & (alg->cra_alignmask + 1))
	64	return -EINVAL;
	65
cce9e06d HX	66	if (alg->cra_blocksize > PAGE_SIZE / 8)
	67	return -EINVAL;
	68
	69	if (alg->cra_priority < 0)
	70	return -EINVAL;
cce9e06d	71
4cc7720c HX	72	return crypto_set_driver_name(alg);
	73	}
	74
6bfd4809 HX	75	static void crypto_destroy_instance(struct crypto_alg *alg)
	76	{
	77	struct crypto_instance inst = (void )alg;
	78	struct crypto_template *tmpl = inst->tmpl;
	79
	80	tmpl->free(inst);
	81	crypto_tmpl_put(tmpl);
	82	}
	83
a73e6996 HX	84	static void crypto_remove_spawn(struct crypto_spawn *spawn,
	85	struct list_head *list,
	86	struct list_head *secondary_spawns)
6bfd4809	87	{
a73e6996 HX	88	struct crypto_instance *inst = spawn->inst;
a73e6996 HX	89	struct crypto_template *tmpl = inst->tmpl;
6bfd4809	90
a73e6996 HX	91	list_del_init(&spawn->list);
a73e6996 HX	92	spawn->alg = NULL;
6bfd4809	93
a73e6996 HX	94	if (crypto_is_dead(&inst->alg))
a73e6996 HX	95	return;
6bfd4809	96
a73e6996	97	inst->alg.cra_flags \|= CRYPTO_ALG_DEAD;
38cb2419 HX	98	if (hlist_unhashed(&inst->list))
	99	return;
	100
a73e6996 HX	101	if (!tmpl \|\| !crypto_tmpl_get(tmpl))
	102	return;
	103
	104	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg);
	105	list_move(&inst->alg.cra_list, list);
	106	hlist_del(&inst->list);
	107	inst->alg.cra_destroy = crypto_destroy_instance;
	108
	109	list_splice(&inst->alg.cra_users, secondary_spawns);
	110	}
	111
	112	static void crypto_remove_spawns(struct list_head *spawns,
	113	struct list_head *list, u32 new_type)
	114	{
	115	struct crypto_spawn spawn, n;
	116	LIST_HEAD(secondary_spawns);
6bfd4809	117
a73e6996 HX	118	list_for_each_entry_safe(spawn, n, spawns, list) {
a73e6996 HX	119	if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)
6bfd4809 HX	120	continue;
6bfd4809 HX	121
a73e6996 HX	122	crypto_remove_spawn(spawn, list, &secondary_spawns);
a73e6996 HX	123	}
6bfd4809	124
a73e6996 HX	125	while (!list_empty(&secondary_spawns)) {
	126	list_for_each_entry_safe(spawn, n, &secondary_spawns, list)
	127	crypto_remove_spawn(spawn, list, &secondary_spawns);
6bfd4809 HX	128	}
	129	}
	130
73d3864a	131	static struct crypto_larval __crypto_register_alg(struct crypto_alg alg)
4cc7720c HX	132	{
4cc7720c HX	133	struct crypto_alg *q;
73d3864a	134	struct crypto_larval *larval;
6bfd4809 HX	135	int ret = -EAGAIN;
	136
	137	if (crypto_is_dead(alg))
73d3864a	138	goto err;
6bfd4809 HX	139
	140	INIT_LIST_HEAD(&alg->cra_users);
	141
73d3864a HX	142	/* No cheating! */
	143	alg->cra_flags &= ~CRYPTO_ALG_TESTED;
	144
6bfd4809	145	ret = -EEXIST;
4cc7720c	146
2825982d	147	atomic_set(&alg->cra_refcnt, 1);
cce9e06d	148	list_for_each_entry(q, &crypto_alg_list, cra_list) {
4cc7720c	149	if (q == alg)
73d3864a HX	150	goto err;
	151
	152	if (crypto_is_larval(q)) {
	153	if (!strcmp(alg->cra_driver_name, q->cra_driver_name))
	154	goto err;
	155	continue;
	156	}
	157
	158	if (!strcmp(q->cra_driver_name, alg->cra_name) \|\|
	159	!strcmp(q->cra_name, alg->cra_driver_name))
	160	goto err;
	161	}
	162
	163	larval = crypto_larval_alloc(alg->cra_name,
	164	alg->cra_flags \| CRYPTO_ALG_TESTED, 0);
	165	if (IS_ERR(larval))
	166	goto out;
	167
	168	ret = -ENOENT;
	169	larval->adult = crypto_mod_get(alg);
	170	if (!larval->adult)
	171	goto free_larval;
	172
	173	atomic_set(&larval->alg.cra_refcnt, 1);
	174	memcpy(larval->alg.cra_driver_name, alg->cra_driver_name,
	175	CRYPTO_MAX_ALG_NAME);
	176	larval->alg.cra_priority = alg->cra_priority;
	177
	178	list_add(&alg->cra_list, &crypto_alg_list);
	179	list_add(&larval->alg.cra_list, &crypto_alg_list);
	180
	181	out:
	182	return larval;
	183
	184	free_larval:
	185	kfree(larval);
	186	err:
	187	larval = ERR_PTR(ret);
	188	goto out;
	189	}
	190
	191	void crypto_alg_tested(const char *name, int err)
	192	{
	193	struct crypto_larval *test;
	194	struct crypto_alg *alg;
	195	struct crypto_alg *q;
	196	LIST_HEAD(list);
	197
	198	down_write(&crypto_alg_sem);
	199	list_for_each_entry(q, &crypto_alg_list, cra_list) {
	200	if (!crypto_is_larval(q))
	201	continue;
	202
	203	test = (struct crypto_larval *)q;
	204
	205	if (!strcmp(q->cra_driver_name, name))
	206	goto found;
	207	}
	208
	209	printk(KERN_ERR "alg: Unexpected test result for %s: %d\n", name, err);
	210	goto unlock;
	211
	212	found:
	213	alg = test->adult;
214	if (err \|\| list_empty(&alg->cra_list))
215	goto complete;
216
217	alg->cra_flags \|= CRYPTO_ALG_TESTED;
218
219	list_for_each_entry(q, &crypto_alg_list, cra_list) {
220	if (q == alg)
221	continue;
6bfd4809 HX	222
	223	if (crypto_is_moribund(q))
	224	continue;
	225
	226	if (crypto_is_larval(q)) {
2825982d HX	227	struct crypto_larval larval = (void )q;
2825982d HX	228
d8058480 HX	229	/*
	230	* Check to see if either our generic name or
	231	* specific name can satisfy the name requested
	232	* by the larval entry q.
	233	*/
6bfd4809 HX	234	if (strcmp(alg->cra_name, q->cra_name) &&
	235	strcmp(alg->cra_driver_name, q->cra_name))
	236	continue;
	237
	238	if (larval->adult)
	239	continue;
492e2b63 HX	240	if ((q->cra_flags ^ alg->cra_flags) & larval->mask)
492e2b63 HX	241	continue;
2825982d HX	242	if (!crypto_mod_get(alg))
2825982d HX	243	continue;
6bfd4809	244
2825982d	245	larval->adult = alg;
fe3c5206	246	complete_all(&larval->completion);
6bfd4809	247	continue;
2825982d	248	}
6bfd4809 HX	249
	250	if (strcmp(alg->cra_name, q->cra_name))
	251	continue;
	252
	253	if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&
	254	q->cra_priority > alg->cra_priority)
	255	continue;
	256
73d3864a	257	crypto_remove_spawns(&q->cra_users, &list, alg->cra_flags);
cce9e06d	258	}
2825982d	259
73d3864a HX	260	complete:
73d3864a HX	261	complete_all(&test->completion);
2825982d	262
73d3864a HX	263	unlock:
	264	up_write(&crypto_alg_sem);
	265
	266	crypto_remove_final(&list);
cce9e06d	267	}
73d3864a	268	EXPORT_SYMBOL_GPL(crypto_alg_tested);
4cc7720c	269
6bfd4809 HX	270	static void crypto_remove_final(struct list_head *list)
	271	{
	272	struct crypto_alg *alg;
	273	struct crypto_alg *n;
	274
	275	list_for_each_entry_safe(alg, n, list, cra_list) {
	276	list_del_init(&alg->cra_list);
	277	crypto_alg_put(alg);
	278	}
	279	}
	280
73d3864a HX	281	static void crypto_wait_for_test(struct crypto_larval *larval)
	282	{
	283	int err;
	284
	285	err = crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, larval->adult);
	286	if (err != NOTIFY_STOP) {
	287	if (WARN_ON(err != NOTIFY_DONE))
	288	goto out;
	289	crypto_alg_tested(larval->alg.cra_driver_name, 0);
	290	}
	291
	292	err = wait_for_completion_interruptible(&larval->completion);
	293	WARN_ON(err);
	294
	295	out:
	296	crypto_larval_kill(&larval->alg);
	297	}
	298
4cc7720c HX	299	int crypto_register_alg(struct crypto_alg *alg)
4cc7720c HX	300	{
73d3864a	301	struct crypto_larval *larval;
4cc7720c HX	302	int err;
	303
	304	err = crypto_check_alg(alg);
	305	if (err)
	306	return err;
	307
	308	down_write(&crypto_alg_sem);
73d3864a	309	larval = __crypto_register_alg(alg);
4cc7720c HX	310	up_write(&crypto_alg_sem);
4cc7720c HX	311
73d3864a HX	312	if (IS_ERR(larval))
	313	return PTR_ERR(larval);
	314
	315	crypto_wait_for_test(larval);
	316	return 0;
4cc7720c	317	}
cce9e06d HX	318	EXPORT_SYMBOL_GPL(crypto_register_alg);
cce9e06d HX	319
6bfd4809 HX	320	static int crypto_remove_alg(struct crypto_alg alg, struct list_head list)
	321	{
	322	if (unlikely(list_empty(&alg->cra_list)))
	323	return -ENOENT;
	324
	325	alg->cra_flags \|= CRYPTO_ALG_DEAD;
	326
	327	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg);
	328	list_del_init(&alg->cra_list);
a73e6996	329	crypto_remove_spawns(&alg->cra_users, list, alg->cra_flags);
6bfd4809 HX	330
	331	return 0;
	332	}
	333
cce9e06d HX	334	int crypto_unregister_alg(struct crypto_alg *alg)
cce9e06d HX	335	{
6bfd4809 HX	336	int ret;
6bfd4809 HX	337	LIST_HEAD(list);
cce9e06d HX	338
cce9e06d HX	339	down_write(&crypto_alg_sem);
6bfd4809	340	ret = crypto_remove_alg(alg, &list);
cce9e06d HX	341	up_write(&crypto_alg_sem);
	342
	343	if (ret)
	344	return ret;
	345
	346	BUG_ON(atomic_read(&alg->cra_refcnt) != 1);
	347	if (alg->cra_destroy)
	348	alg->cra_destroy(alg);
	349
6bfd4809	350	crypto_remove_final(&list);
cce9e06d HX	351	return 0;
	352	}
	353	EXPORT_SYMBOL_GPL(crypto_unregister_alg);
	354
4cc7720c HX	355	int crypto_register_template(struct crypto_template *tmpl)
	356	{
	357	struct crypto_template *q;
	358	int err = -EEXIST;
	359
	360	down_write(&crypto_alg_sem);
	361
	362	list_for_each_entry(q, &crypto_template_list, list) {
	363	if (q == tmpl)
	364	goto out;
	365	}
	366
	367	list_add(&tmpl->list, &crypto_template_list);
2825982d	368	crypto_notify(CRYPTO_MSG_TMPL_REGISTER, tmpl);
4cc7720c HX	369	err = 0;
	370	out:
	371	up_write(&crypto_alg_sem);
	372	return err;
	373	}
	374	EXPORT_SYMBOL_GPL(crypto_register_template);
	375
	376	void crypto_unregister_template(struct crypto_template *tmpl)
	377	{
	378	struct crypto_instance *inst;
	379	struct hlist_node p, n;
	380	struct hlist_head *list;
6bfd4809	381	LIST_HEAD(users);
4cc7720c HX	382
	383	down_write(&crypto_alg_sem);
	384
	385	BUG_ON(list_empty(&tmpl->list));
	386	list_del_init(&tmpl->list);
	387
	388	list = &tmpl->instances;
	389	hlist_for_each_entry(inst, p, list, list) {
6bfd4809 HX	390	int err = crypto_remove_alg(&inst->alg, &users);
6bfd4809 HX	391	BUG_ON(err);
4cc7720c HX	392	}
4cc7720c HX	393
2825982d HX	394	crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl);
2825982d HX	395
4cc7720c HX	396	up_write(&crypto_alg_sem);
	397
	398	hlist_for_each_entry_safe(inst, p, n, list, list) {
	399	BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1);
	400	tmpl->free(inst);
	401	}
6bfd4809	402	crypto_remove_final(&users);
4cc7720c HX	403	}
	404	EXPORT_SYMBOL_GPL(crypto_unregister_template);
	405
	406	static struct crypto_template __crypto_lookup_template(const char name)
	407	{
	408	struct crypto_template q, tmpl = NULL;
	409
	410	down_read(&crypto_alg_sem);
	411	list_for_each_entry(q, &crypto_template_list, list) {
	412	if (strcmp(q->name, name))
	413	continue;
	414	if (unlikely(!crypto_tmpl_get(q)))
	415	continue;
	416
	417	tmpl = q;
	418	break;
	419	}
	420	up_read(&crypto_alg_sem);
	421
	422	return tmpl;
	423	}
	424
	425	struct crypto_template crypto_lookup_template(const char name)
	426	{
	427	return try_then_request_module(__crypto_lookup_template(name), name);
	428	}
	429	EXPORT_SYMBOL_GPL(crypto_lookup_template);
	430
	431	int crypto_register_instance(struct crypto_template *tmpl,
	432	struct crypto_instance *inst)
	433	{
73d3864a HX	434	struct crypto_larval *larval;
73d3864a HX	435	int err;
4cc7720c	436
4cc7720c HX	437	err = crypto_check_alg(&inst->alg);
	438	if (err)
	439	goto err;
	440
	441	inst->alg.cra_module = tmpl->module;
	442
	443	down_write(&crypto_alg_sem);
	444
73d3864a HX	445	larval = __crypto_register_alg(&inst->alg);
73d3864a HX	446	if (IS_ERR(larval))
4cc7720c HX	447	goto unlock;
	448
	449	hlist_add_head(&inst->list, &tmpl->instances);
	450	inst->tmpl = tmpl;
	451
	452	unlock:
	453	up_write(&crypto_alg_sem);
	454
73d3864a HX	455	err = PTR_ERR(larval);
	456	if (IS_ERR(larval))
	457	goto err;
	458
	459	crypto_wait_for_test(larval);
	460	err = 0;
6bfd4809	461
4cc7720c HX	462	err:
	463	return err;
	464	}
	465	EXPORT_SYMBOL_GPL(crypto_register_instance);
	466
6bfd4809	467	int crypto_init_spawn(struct crypto_spawn spawn, struct crypto_alg alg,
a73e6996	468	struct crypto_instance *inst, u32 mask)
6bfd4809 HX	469	{
	470	int err = -EAGAIN;
	471
	472	spawn->inst = inst;
a73e6996	473	spawn->mask = mask;
6bfd4809 HX	474
	475	down_write(&crypto_alg_sem);
	476	if (!crypto_is_moribund(alg)) {
	477	list_add(&spawn->list, &alg->cra_users);
	478	spawn->alg = alg;
	479	err = 0;
	480	}
	481	up_write(&crypto_alg_sem);
	482
	483	return err;
	484	}
	485	EXPORT_SYMBOL_GPL(crypto_init_spawn);
	486
	487	void crypto_drop_spawn(struct crypto_spawn *spawn)
	488	{
	489	down_write(&crypto_alg_sem);
	490	list_del(&spawn->list);
	491	up_write(&crypto_alg_sem);
	492	}
	493	EXPORT_SYMBOL_GPL(crypto_drop_spawn);
	494
2e306ee0 HX	495	struct crypto_tfm crypto_spawn_tfm(struct crypto_spawn spawn, u32 type,
2e306ee0 HX	496	u32 mask)
6bfd4809 HX	497	{
	498	struct crypto_alg *alg;
	499	struct crypto_alg *alg2;
	500	struct crypto_tfm *tfm;
	501
	502	down_read(&crypto_alg_sem);
	503	alg = spawn->alg;
	504	alg2 = alg;
	505	if (alg2)
	506	alg2 = crypto_mod_get(alg2);
	507	up_read(&crypto_alg_sem);
	508
	509	if (!alg2) {
	510	if (alg)
	511	crypto_shoot_alg(alg);
	512	return ERR_PTR(-EAGAIN);
	513	}
	514
2e306ee0 HX	515	tfm = ERR_PTR(-EINVAL);
	516	if (unlikely((alg->cra_flags ^ type) & mask))
	517	goto out_put_alg;
	518
27d2a330	519	tfm = __crypto_alloc_tfm(alg, type, mask);
6bfd4809	520	if (IS_ERR(tfm))
2e306ee0 HX	521	goto out_put_alg;
	522
	523	return tfm;
6bfd4809	524
2e306ee0 HX	525	out_put_alg:
2e306ee0 HX	526	crypto_mod_put(alg);
6bfd4809 HX	527	return tfm;
	528	}
	529	EXPORT_SYMBOL_GPL(crypto_spawn_tfm);
	530
2825982d HX	531	int crypto_register_notifier(struct notifier_block *nb)
	532	{
	533	return blocking_notifier_chain_register(&crypto_chain, nb);
	534	}
	535	EXPORT_SYMBOL_GPL(crypto_register_notifier);
	536
	537	int crypto_unregister_notifier(struct notifier_block *nb)
	538	{
	539	return blocking_notifier_chain_unregister(&crypto_chain, nb);
	540	}
	541	EXPORT_SYMBOL_GPL(crypto_unregister_notifier);
	542
ebc610e5	543	struct crypto_attr_type crypto_get_attr_type(struct rtattr *tb)
7fed0bf2	544	{
39e1ee01	545	struct rtattr *rta = tb[0];
ebc610e5 HX	546	struct crypto_attr_type *algt;
	547
	548	if (!rta)
	549	return ERR_PTR(-ENOENT);
	550	if (RTA_PAYLOAD(rta) < sizeof(*algt))
	551	return ERR_PTR(-EINVAL);
39e1ee01 HX	552	if (rta->rta_type != CRYPTOA_TYPE)
39e1ee01 HX	553	return ERR_PTR(-EINVAL);
ebc610e5 HX	554
	555	algt = RTA_DATA(rta);
	556
	557	return algt;
	558	}
	559	EXPORT_SYMBOL_GPL(crypto_get_attr_type);
	560
	561	int crypto_check_attr_type(struct rtattr **tb, u32 type)
	562	{
	563	struct crypto_attr_type *algt;
	564
	565	algt = crypto_get_attr_type(tb);
	566	if (IS_ERR(algt))
	567	return PTR_ERR(algt);
	568
	569	if ((algt->type ^ type) & algt->mask)
	570	return -EINVAL;
	571
	572	return 0;
	573	}
	574	EXPORT_SYMBOL_GPL(crypto_check_attr_type);
	575
68b6c7d6	576	const char crypto_attr_alg_name(struct rtattr rta)
ebc610e5	577	{
7fed0bf2 HX	578	struct crypto_attr_alg *alga;
7fed0bf2 HX	579
ebc610e5 HX	580	if (!rta)
	581	return ERR_PTR(-ENOENT);
	582	if (RTA_PAYLOAD(rta) < sizeof(*alga))
7fed0bf2	583	return ERR_PTR(-EINVAL);
39e1ee01 HX	584	if (rta->rta_type != CRYPTOA_ALG)
39e1ee01 HX	585	return ERR_PTR(-EINVAL);
7fed0bf2 HX	586
	587	alga = RTA_DATA(rta);
	588	alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0;
	589
68b6c7d6 HX	590	return alga->name;
	591	}
	592	EXPORT_SYMBOL_GPL(crypto_attr_alg_name);
	593
	594	struct crypto_alg crypto_attr_alg(struct rtattr rta, u32 type, u32 mask)
	595	{
	596	const char *name;
	597	int err;
	598
	599	name = crypto_attr_alg_name(rta);
	600	err = PTR_ERR(name);
	601	if (IS_ERR(name))
	602	return ERR_PTR(err);
	603
	604	return crypto_alg_mod_lookup(name, type, mask);
7fed0bf2	605	}
3c09f17c HX	606	EXPORT_SYMBOL_GPL(crypto_attr_alg);
	607
	608	int crypto_attr_u32(struct rtattr rta, u32 num)
	609	{
	610	struct crypto_attr_u32 *nu32;
	611
	612	if (!rta)
	613	return -ENOENT;
	614	if (RTA_PAYLOAD(rta) < sizeof(*nu32))
	615	return -EINVAL;
	616	if (rta->rta_type != CRYPTOA_U32)
	617	return -EINVAL;
	618
	619	nu32 = RTA_DATA(rta);
	620	*num = nu32->num;
	621
	622	return 0;
	623	}
	624	EXPORT_SYMBOL_GPL(crypto_attr_u32);
7fed0bf2 HX	625
	626	struct crypto_instance crypto_alloc_instance(const char name,
	627	struct crypto_alg *alg)
	628	{
	629	struct crypto_instance *inst;
	630	struct crypto_spawn *spawn;
	631	int err;
	632
	633	inst = kzalloc(sizeof(inst) + sizeof(spawn), GFP_KERNEL);
	634	if (!inst)
	635	return ERR_PTR(-ENOMEM);
	636
	637	err = -ENAMETOOLONG;
	638	if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name,
	639	alg->cra_name) >= CRYPTO_MAX_ALG_NAME)
	640	goto err_free_inst;
	641
	642	if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)",
	643	name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
	644	goto err_free_inst;
	645
	646	spawn = crypto_instance_ctx(inst);
a73e6996 HX	647	err = crypto_init_spawn(spawn, alg, inst,
a73e6996 HX	648	CRYPTO_ALG_TYPE_MASK \| CRYPTO_ALG_ASYNC);
7fed0bf2 HX	649
	650	if (err)
	651	goto err_free_inst;
	652
	653	return inst;
	654
	655	err_free_inst:
	656	kfree(inst);
	657	return ERR_PTR(err);
	658	}
	659	EXPORT_SYMBOL_GPL(crypto_alloc_instance);
	660
b5b7f088 HX	661	void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen)
	662	{
	663	INIT_LIST_HEAD(&queue->list);
	664	queue->backlog = &queue->list;
	665	queue->qlen = 0;
	666	queue->max_qlen = max_qlen;
	667	}
	668	EXPORT_SYMBOL_GPL(crypto_init_queue);
	669
	670	int crypto_enqueue_request(struct crypto_queue *queue,
	671	struct crypto_async_request *request)
	672	{
	673	int err = -EINPROGRESS;
	674
	675	if (unlikely(queue->qlen >= queue->max_qlen)) {
	676	err = -EBUSY;
	677	if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
	678	goto out;
	679	if (queue->backlog == &queue->list)
	680	queue->backlog = &request->list;
	681	}
	682
	683	queue->qlen++;
	684	list_add_tail(&request->list, &queue->list);
	685
	686	out:
	687	return err;
	688	}
	689	EXPORT_SYMBOL_GPL(crypto_enqueue_request);
	690
	691	struct crypto_async_request crypto_dequeue_request(struct crypto_queue queue)
	692	{
	693	struct list_head *request;
	694
	695	if (unlikely(!queue->qlen))
	696	return NULL;
	697
	698	queue->qlen--;
	699
	700	if (queue->backlog != &queue->list)
	701	queue->backlog = queue->backlog->next;
	702
	703	request = queue->list.next;
	704	list_del(request);
	705
	706	return list_entry(request, struct crypto_async_request, list);
	707	}
	708	EXPORT_SYMBOL_GPL(crypto_dequeue_request);
	709
	710	int crypto_tfm_in_queue(struct crypto_queue queue, struct crypto_tfm tfm)
	711	{
	712	struct crypto_async_request *req;
	713
	714	list_for_each_entry(req, &queue->list, list) {
	715	if (req->tfm == tfm)
	716	return 1;
	717	}
	718
	719	return 0;
	720	}
	721	EXPORT_SYMBOL_GPL(crypto_tfm_in_queue);
	722
7613636d HX	723	static inline void crypto_inc_byte(u8 *a, unsigned int size)
	724	{
	725	u8 *b = (a + size);
	726	u8 c;
	727
	728	for (; size; size--) {
	729	c = *--b + 1;
	730	*b = c;
	731	if (c)
	732	break;
	733	}
	734	}
	735
	736	void crypto_inc(u8 *a, unsigned int size)
	737	{
	738	__be32 b = (__be32 )(a + size);
	739	u32 c;
	740
	741	for (; size >= 4; size -= 4) {
	742	c = be32_to_cpu(*--b) + 1;
	743	*b = cpu_to_be32(c);
	744	if (c)
	745	return;
	746	}
	747
	748	crypto_inc_byte(a, size);
	749	}
	750	EXPORT_SYMBOL_GPL(crypto_inc);
	751
	752	static inline void crypto_xor_byte(u8 a, const u8 b, unsigned int size)
	753	{
	754	for (; size; size--)
	755	a++ ^= b++;
	756	}
	757
	758	void crypto_xor(u8 dst, const u8 src, unsigned int size)
	759	{
	760	u32 a = (u32 )dst;
	761	u32 b = (u32 )src;
	762
	763	for (; size >= 4; size -= 4)
	764	a++ ^= b++;
	765
	766	crypto_xor_byte((u8 )a, (u8 )b, size);
	767	}
	768	EXPORT_SYMBOL_GPL(crypto_xor);
	769
cce9e06d HX	770	static int __init crypto_algapi_init(void)
	771	{
	772	crypto_init_proc();
	773	return 0;
	774	}
	775
	776	static void __exit crypto_algapi_exit(void)
	777	{
	778	crypto_exit_proc();
	779	}
	780
	781	module_init(crypto_algapi_init);
	782	module_exit(crypto_algapi_exit);
	783
	784	MODULE_LICENSE("GPL");
	785	MODULE_DESCRIPTION("Cryptographic algorithms API");