Commit 629f1afc authored by Eric Biggers's avatar Eric Biggers Committed by Herbert Xu
Browse files

crypto: algapi - remove obsoleted instance creation helpers 



Remove lots of helper functions that were previously used for
instantiating crypto templates, but are now unused:

- crypto_get_attr_alg() and similar functions looked up an inner
  algorithm directly from a template parameter.  These were replaced
  with getting the algorithm's name, then calling crypto_grab_*().

- crypto_init_spawn2() and similar functions initialized a spawn, given
  an algorithm.  Similarly, these were replaced with crypto_grab_*().

- crypto_alloc_instance() and similar functions allocated an instance
  with a single spawn, given the inner algorithm.  These aren't useful
  anymore since crypto_grab_*() need the instance allocated first.

Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent d5ed3b65

crypto/ahash.c

+0 −25
Original line number Diff line number Diff line
@@ -655,31 +655,6 @@ int ahash_register_instance(struct crypto_template *tmpl, 
}

EXPORT_SYMBOL_GPL(ahash_register_instance);



void ahash_free_instance(struct crypto_instance *inst)

{

	crypto_drop_spawn(crypto_instance_ctx(inst));

	kfree(ahash_instance(inst));

}

EXPORT_SYMBOL_GPL(ahash_free_instance);



int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,

			    struct hash_alg_common *alg,

			    struct crypto_instance *inst)

{

	return crypto_init_spawn2(&spawn->base, &alg->base, inst,

				  &crypto_ahash_type);

}

EXPORT_SYMBOL_GPL(crypto_init_ahash_spawn);



struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask)

{

	struct crypto_alg *alg;



	alg = crypto_attr_alg2(rta, &crypto_ahash_type, type, mask);

	return IS_ERR(alg) ? ERR_CAST(alg) : __crypto_hash_alg_common(alg);

}

EXPORT_SYMBOL_GPL(ahash_attr_alg);



bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg)

{

	struct crypto_alg *alg = &halg->base;

crypto/algapi.c

+0 −57
Original line number Diff line number Diff line
@@ -697,23 +697,6 @@ int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg, 
}

EXPORT_SYMBOL_GPL(crypto_init_spawn);



int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,

		       struct crypto_instance *inst,

		       const struct crypto_type *frontend)

{

	int err = -EINVAL;



	if ((alg->cra_flags ^ frontend->type) & frontend->maskset)

		goto out;



	spawn->frontend = frontend;

	err = crypto_init_spawn(spawn, alg, inst, frontend->maskset);



out:

	return err;

}

EXPORT_SYMBOL_GPL(crypto_init_spawn2);



int crypto_grab_spawn(struct crypto_spawn *spawn, struct crypto_instance *inst,

		      const char *name, u32 type, u32 mask)

{
@@ -876,20 +859,6 @@ const char *crypto_attr_alg_name(struct rtattr *rta) 
}

EXPORT_SYMBOL_GPL(crypto_attr_alg_name);



struct crypto_alg *crypto_attr_alg2(struct rtattr *rta,

				    const struct crypto_type *frontend,

				    u32 type, u32 mask)

{

	const char *name;



	name = crypto_attr_alg_name(rta);

	if (IS_ERR(name))

		return ERR_CAST(name);



	return crypto_find_alg(name, frontend, type, mask);

}

EXPORT_SYMBOL_GPL(crypto_attr_alg2);



int crypto_attr_u32(struct rtattr *rta, u32 *num)

{

	struct crypto_attr_u32 *nu32;
@@ -923,32 +892,6 @@ int crypto_inst_setname(struct crypto_instance *inst, const char *name, 
}

EXPORT_SYMBOL_GPL(crypto_inst_setname);



void *crypto_alloc_instance(const char *name, struct crypto_alg *alg,

			    unsigned int head)

{

	struct crypto_instance *inst;

	char *p;

	int err;



	p = kzalloc(head + sizeof(*inst) + sizeof(struct crypto_spawn),

		    GFP_KERNEL);

	if (!p)

		return ERR_PTR(-ENOMEM);



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



	err = crypto_inst_setname(inst, name, alg);

	if (err)

		goto err_free_inst;



	return p;



err_free_inst:

	kfree(p);

	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);

crypto/shash.c

+0 −19
Original line number Diff line number Diff line
@@ -584,24 +584,5 @@ void shash_free_instance(struct crypto_instance *inst) 
}

EXPORT_SYMBOL_GPL(shash_free_instance);



int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,

			    struct shash_alg *alg,

			    struct crypto_instance *inst)

{

	return crypto_init_spawn2(&spawn->base, &alg->base, inst,

				  &crypto_shash_type);

}

EXPORT_SYMBOL_GPL(crypto_init_shash_spawn);



struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask)

{

	struct crypto_alg *alg;



	alg = crypto_attr_alg2(rta, &crypto_shash_type, type, mask);

	return IS_ERR(alg) ? ERR_CAST(alg) :

	       container_of(alg, struct shash_alg, base);

}

EXPORT_SYMBOL_GPL(shash_attr_alg);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Synchronous cryptographic hash type");

include/crypto/algapi.h

+0 −22
Original line number Diff line number Diff line
@@ -113,12 +113,8 @@ void crypto_unregister_instance(struct crypto_instance *inst); 


int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,

		      struct crypto_instance *inst, u32 mask);

int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,

		       struct crypto_instance *inst,

		       const struct crypto_type *frontend);

int crypto_grab_spawn(struct crypto_spawn *spawn, struct crypto_instance *inst,

		      const char *name, u32 type, u32 mask);



void crypto_drop_spawn(struct crypto_spawn *spawn);

struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,

				    u32 mask);
@@ -127,21 +123,9 @@ void *crypto_spawn_tfm2(struct crypto_spawn *spawn); 
struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb);

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

const char *crypto_attr_alg_name(struct rtattr *rta);

struct crypto_alg *crypto_attr_alg2(struct rtattr *rta,

				    const struct crypto_type *frontend,

				    u32 type, u32 mask);



static inline struct crypto_alg *crypto_attr_alg(struct rtattr *rta,

						 u32 type, u32 mask)

{

	return crypto_attr_alg2(rta, NULL, type, mask);

}



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

int crypto_inst_setname(struct crypto_instance *inst, const char *name,

			struct crypto_alg *alg);

void *crypto_alloc_instance(const char *name, struct crypto_alg *alg,

			    unsigned int head);



void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen);

int crypto_enqueue_request(struct crypto_queue *queue,
@@ -254,12 +238,6 @@ static inline struct crypto_async_request *crypto_get_backlog( 
	       container_of(queue->backlog, struct crypto_async_request, list);

}



static inline struct crypto_alg *crypto_get_attr_alg(struct rtattr **tb,

						     u32 type, u32 mask)

{

	return crypto_attr_alg(tb[1], type, mask);

}



static inline int crypto_requires_off(u32 type, u32 mask, u32 off)

{

	return (type ^ off) & mask & off;

include/crypto/internal/hash.h

+0 −31
Original line number Diff line number Diff line
@@ -87,7 +87,6 @@ int crypto_register_ahashes(struct ahash_alg *algs, int count); 
void crypto_unregister_ahashes(struct ahash_alg *algs, int count);

int ahash_register_instance(struct crypto_template *tmpl,

			    struct ahash_instance *inst);

void ahash_free_instance(struct crypto_instance *inst);



int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,

		    unsigned int keylen);
@@ -105,10 +104,6 @@ static inline bool crypto_shash_alg_needs_key(struct shash_alg *alg) 


bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg);



int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,

			    struct hash_alg_common *alg,

			    struct crypto_instance *inst);



int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,

		      struct crypto_instance *inst,

		      const char *name, u32 type, u32 mask);
@@ -124,8 +119,6 @@ static inline struct hash_alg_common *crypto_spawn_ahash_alg( 
	return __crypto_hash_alg_common(spawn->base.alg);

}



struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask);



int crypto_register_shash(struct shash_alg *alg);

void crypto_unregister_shash(struct shash_alg *alg);

int crypto_register_shashes(struct shash_alg *algs, int count);
@@ -134,10 +127,6 @@ int shash_register_instance(struct crypto_template *tmpl, 
			    struct shash_instance *inst);

void shash_free_instance(struct crypto_instance *inst);



int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,

			    struct shash_alg *alg,

			    struct crypto_instance *inst);



int crypto_grab_shash(struct crypto_shash_spawn *spawn,

		      struct crypto_instance *inst,

		      const char *name, u32 type, u32 mask);
@@ -153,8 +142,6 @@ static inline struct shash_alg *crypto_spawn_shash_alg( 
	return __crypto_shash_alg(spawn->base.alg);

}



struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask);



int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);

int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);

int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
@@ -195,17 +182,6 @@ static inline void *ahash_instance_ctx(struct ahash_instance *inst) 
	return crypto_instance_ctx(ahash_crypto_instance(inst));

}



static inline unsigned int ahash_instance_headroom(void)

{

	return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);

}



static inline struct ahash_instance *ahash_alloc_instance(

	const char *name, struct crypto_alg *alg)

{

	return crypto_alloc_instance(name, alg, ahash_instance_headroom());

}



static inline void ahash_request_complete(struct ahash_request *req, int err)

{

	req->base.complete(&req->base, err);
@@ -262,13 +238,6 @@ static inline void *shash_instance_ctx(struct shash_instance *inst) 
	return crypto_instance_ctx(shash_crypto_instance(inst));

}



static inline struct shash_instance *shash_alloc_instance(

	const char *name, struct crypto_alg *alg)

{

	return crypto_alloc_instance(name, alg,

				     sizeof(struct shash_alg) - sizeof(*alg));

}



static inline struct crypto_shash *crypto_spawn_shash(

	struct crypto_shash_spawn *spawn)

{