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

crypto: algapi - make unregistration functions return void 



Some of the algorithm unregistration functions return -ENOENT when asked
to unregister a non-registered algorithm, while others always return 0
or always return void.  But no users check the return value, except for
two of the bulk unregistration functions which print a message on error
but still always return 0 to their caller, and crypto_del_alg() which
calls crypto_unregister_instance() which always returns 0.

Since unregistering a non-registered algorithm is always a kernel bug
but there isn't anything callers should do to handle this situation at
runtime, let's simplify things by making all the unregistration
functions return void, and moving the error message into
crypto_unregister_alg() and upgrading it to a WARN().

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

Documentation/crypto/devel-algos.rst

+12 −22
Original line number Diff line number Diff line
@@ -31,28 +31,18 @@ The counterparts to those functions are listed below. 


::



       int crypto_unregister_alg(struct crypto_alg *alg);

       int crypto_unregister_algs(struct crypto_alg *algs, int count);

       void crypto_unregister_alg(struct crypto_alg *alg);

       void crypto_unregister_algs(struct crypto_alg *algs, int count);





Notice that both registration and unregistration functions do return a

value, so make sure to handle errors. A return code of zero implies

success. Any return code < 0 implies an error.

The registration functions return 0 on success, or a negative errno

value on failure.  crypto_register_algs() succeeds only if it

successfully registered all the given algorithms; if it fails partway

through, then any changes are rolled back.



The bulk registration/unregistration functions register/unregister each

transformation in the given array of length count. They handle errors as

follows:



-  crypto_register_algs() succeeds if and only if it successfully

   registers all the given transformations. If an error occurs partway

   through, then it rolls back successful registrations before returning

   the error code. Note that if a driver needs to handle registration

   errors for individual transformations, then it will need to use the

   non-bulk function crypto_register_alg() instead.



-  crypto_unregister_algs() tries to unregister all the given

   transformations, continuing on error. It logs errors and always

   returns zero.

The unregistration functions always succeed, so they don't have a

return value.  Don't try to unregister algorithms that aren't

currently registered.



Single-Block Symmetric Ciphers [CIPHER]

---------------------------------------
@@ -169,10 +159,10 @@ are as follows: 


::



       int crypto_unregister_ahash(struct ahash_alg *alg);

       void crypto_unregister_ahash(struct ahash_alg *alg);



       int crypto_unregister_shash(struct shash_alg *alg);

       int crypto_unregister_shashes(struct shash_alg *algs, int count);

       void crypto_unregister_shash(struct shash_alg *alg);

       void crypto_unregister_shashes(struct shash_alg *algs, int count);





Cipher Definition With struct shash_alg and ahash_alg

crypto/acompress.c

+2 −2
Original line number Diff line number Diff line
@@ -151,9 +151,9 @@ int crypto_register_acomp(struct acomp_alg *alg) 
}

EXPORT_SYMBOL_GPL(crypto_register_acomp);



int crypto_unregister_acomp(struct acomp_alg *alg)

void crypto_unregister_acomp(struct acomp_alg *alg)

{

	return crypto_unregister_alg(&alg->base);

	crypto_unregister_alg(&alg->base);

}

EXPORT_SYMBOL_GPL(crypto_unregister_acomp);

crypto/ahash.c

+2 −2
Original line number Diff line number Diff line
@@ -598,9 +598,9 @@ int crypto_register_ahash(struct ahash_alg *alg) 
}

EXPORT_SYMBOL_GPL(crypto_register_ahash);



int crypto_unregister_ahash(struct ahash_alg *alg)

void crypto_unregister_ahash(struct ahash_alg *alg)

{

	return crypto_unregister_alg(&alg->halg.base);

	crypto_unregister_alg(&alg->halg.base);

}

EXPORT_SYMBOL_GPL(crypto_unregister_ahash);

crypto/algapi.c

+8 −17
Original line number Diff line number Diff line
@@ -442,7 +442,7 @@ static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list) 
	return 0;

}



int crypto_unregister_alg(struct crypto_alg *alg)

void crypto_unregister_alg(struct crypto_alg *alg)

{

	int ret;

	LIST_HEAD(list);
@@ -451,15 +451,14 @@ int crypto_unregister_alg(struct crypto_alg *alg) 
	ret = crypto_remove_alg(alg, &list);

	up_write(&crypto_alg_sem);



	if (ret)

		return ret;

	if (WARN(ret, "Algorithm %s is not registered", alg->cra_driver_name))

		return;



	BUG_ON(refcount_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);
@@ -483,18 +482,12 @@ err: 
}

EXPORT_SYMBOL_GPL(crypto_register_algs);



int crypto_unregister_algs(struct crypto_alg *algs, int count)

void crypto_unregister_algs(struct crypto_alg *algs, int count)

{

	int i, ret;



	for (i = 0; i < count; i++) {

		ret = crypto_unregister_alg(&algs[i]);

		if (ret)

			pr_err("Failed to unregister %s %s: %d\n",

			       algs[i].cra_driver_name, algs[i].cra_name, ret);

	}

	int i;



	return 0;

	for (i = 0; i < count; i++)

		crypto_unregister_alg(&algs[i]);

}

EXPORT_SYMBOL_GPL(crypto_unregister_algs);
@@ -639,7 +632,7 @@ err: 
}

EXPORT_SYMBOL_GPL(crypto_register_instance);



int crypto_unregister_instance(struct crypto_instance *inst)

void crypto_unregister_instance(struct crypto_instance *inst)

{

	LIST_HEAD(list);
@@ -651,8 +644,6 @@ int crypto_unregister_instance(struct crypto_instance *inst) 
	up_write(&crypto_alg_sem);



	crypto_remove_final(&list);



	return 0;

}

EXPORT_SYMBOL_GPL(crypto_unregister_instance);

crypto/crypto_user_base.c

+2 −1
Original line number Diff line number Diff line
@@ -323,7 +323,8 @@ static int crypto_del_alg(struct sk_buff *skb, struct nlmsghdr *nlh, 
	if (refcount_read(&alg->cra_refcnt) > 2)

		goto drop_alg;



	err = crypto_unregister_instance((struct crypto_instance *)alg);

	crypto_unregister_instance((struct crypto_instance *)alg);

	err = 0;



drop_alg:

	crypto_mod_put(alg);

CRA Git | Maintained and supported by SUSTech CRA and CCSE