crypto: lrw - prefix function and struct names with "lrw"
PATCH 1/1 crypto: lrw - prefix function and struct names with "lrw"
From: Eric Biggers <[email protected]>
Overly-generic names can cause problems like naming collisions, confusing crash reports, and reduced grep-ability. E.g. see commit d099ea6e6fde ("crypto - Avoid free() namespace collision").
Clean this up for the lrw template by prefixing the names with "lrw_".
(I didn't use "crypto_lrw_" instead because that seems overkill.)
Also constify the tfm context in a couple places.
--- crypto/lrw.c | 119 ++++++++++++++++++++++++++------------------------- 1 file changed, 61 insertions(+), 58 deletions(-)
crypto/lrw.c +61 -58
@@ -27,7 +27,7 @@#define LRW_BLOCK_SIZE 16 -struct priv { +struct lrw_tfm_ctx {struct crypto_skcipher *child;/*
@@ -49,12 +49,12 @@ struct priv {be128 mulinc[128 ]; }; -struct rctx { +struct lrw_request_ctx {be128 t;struct skcipher_request subreq; }; -static inline void setbit128_bbe (void *b,int bit) +static inline void lrw_setbit128_bbe (void *b,int bit) { __set_bit(bit ^ (0x80 - #ifdef __BIG_ENDIAN
@@ -65,10 +65,10 @@ static inline void setbit128_bbe(void *b, int bit) ), b); } -static int setkey (struct crypto_skcipher *parent,const u8 *key, -unsigned int keylen) +static int lrw_setkey (struct crypto_skcipher *parent,const u8 *key, +unsigned int keylen) { -struct priv *ctx =crypto_skcipher_ctx (parent); +struct lrw_tfm_ctx *ctx =crypto_skcipher_ctx (parent);struct crypto_skcipher *child = ctx->child;int err, bsize =LRW_BLOCK_SIZE ;const u8 *tweak = key + keylen - bsize;
@@ -92,7 +92,7 @@ static int setkey(struct crypto_skcipher *parent, const u8 *key,/* initialize optimization table */ for (i =0 ; i <128 ; i++) { -setbit128_bbe (&tmp, i); +lrw_setbit128_bbe (&tmp, i); ctx->mulinc[i] = tmp;gf128mul_64k_bbe (&ctx->mulinc[i], ctx->table); }
@@ -108,10 +108,10 @@ static int setkey(struct crypto_skcipher *parent, const u8 *key,* For example: * * u32 counter[4] = { 0xFFFFFFFF, 0x1, 0x0, 0x0 }; -* int i = next_index(&counter); +* int i = lrw_next_index(&counter); * // i == 33, counter == { 0x0, 0x2, 0x0, 0x0 } */ -static int next_index (u32 *counter) +static int lrw_next_index (u32 *counter) {int i, res =0 ;
@@ -135,14 +135,14 @@ static int next_index(u32 *counter)* We compute the tweak masks twice (both before and after the ECB encryption or * decryption) to avoid having to allocate a temporary buffer and/or make * mutliple calls to the 'ecb(..)' instance, which usually would be slower than -* just doing the next_index() calls again. +* just doing the lrw_next_index() calls again. */ -static int xor_tweak (struct skcipher_request *req,bool second_pass) +static int lrw_xor_tweak (struct skcipher_request *req,bool second_pass) {const int bs =LRW_BLOCK_SIZE ;struct crypto_skcipher *tfm =crypto_skcipher_reqtfm (req); -struct priv *ctx =crypto_skcipher_ctx (tfm); -struct rctx *rctx =skcipher_request_ctx (req); +const struct lrw_tfm_ctx *ctx =crypto_skcipher_ctx (tfm); +struct lrw_request_ctx *rctx =skcipher_request_ctx (req);be128 t = rctx->t;struct skcipher_walk w;__be32 *iv;
@@ -178,7 +178,8 @@ static int xor_tweak(struct skcipher_request *req, bool second_pass)/* T <- I*Key2, using the optimization * discussed in the specification */ -be128_xor (&t, &t, &ctx->mulinc[next_index (counter)]); +be128_xor (&t, &t, + &ctx->mulinc[lrw_next_index (counter)]); }while ((avail -= bs) >= bs);if (second_pass && w.nbytes == w.total) {
@@ -194,38 +195,40 @@ static int xor_tweak(struct skcipher_request *req, bool second_pass)return err; } -static int xor_tweak_pre (struct skcipher_request *req) +static int lrw_xor_tweak_pre (struct skcipher_request *req) { -return xor_tweak (req, false); +return lrw_xor_tweak (req, false); } -static int xor_tweak_post (struct skcipher_request *req) +static int lrw_xor_tweak_post (struct skcipher_request *req) { -return xor_tweak (req, true); +return lrw_xor_tweak (req, true); } -static void crypt_done (struct crypto_async_request *areq,int err) +static void lrw_crypt_done (struct crypto_async_request *areq,int err) {struct skcipher_request *req = areq->data;if (!err) { -struct rctx *rctx =skcipher_request_ctx (req); +struct lrw_request_ctx *rctx =skcipher_request_ctx (req); rctx->subreq.base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP ; - err =xor_tweak_post (req); + err =lrw_xor_tweak_post (req); }skcipher_request_complete (req, err); } -static void init_crypt (struct skcipher_request *req) +static void lrw_init_crypt (struct skcipher_request *req) { -struct priv *ctx =crypto_skcipher_ctx (crypto_skcipher_reqtfm (req)); -struct rctx *rctx =skcipher_request_ctx (req); +const struct lrw_tfm_ctx *ctx = +crypto_skcipher_ctx (crypto_skcipher_reqtfm (req)); +struct lrw_request_ctx *rctx =skcipher_request_ctx (req);struct skcipher_request *subreq = &rctx->subreq;skcipher_request_set_tfm (subreq, ctx->child); -skcipher_request_set_callback (subreq, req->base.flags, crypt_done, req); +skcipher_request_set_callback (subreq, req->base.flags, lrw_crypt_done, + req);/* pass req->iv as IV (will be used by xor_tweak, ECB will ignore it) */ skcipher_request_set_crypt (subreq, req->dst, req->dst, req->cryptlen, req->iv);
@@ -237,33 +240,33 @@ static void init_crypt(struct skcipher_request *req)gf128mul_64k_bbe (&rctx->t, ctx->table); } -static int encrypt (struct skcipher_request *req) +static int lrw_encrypt (struct skcipher_request *req) { -struct rctx *rctx =skcipher_request_ctx (req); +struct lrw_request_ctx *rctx =skcipher_request_ctx (req);struct skcipher_request *subreq = &rctx->subreq; -init_crypt (req); -return xor_tweak_pre (req) ?: +lrw_init_crypt (req); +return lrw_xor_tweak_pre (req) ?:crypto_skcipher_encrypt (subreq) ?: -xor_tweak_post (req); +lrw_xor_tweak_post (req); } -static int decrypt (struct skcipher_request *req) +static int lrw_decrypt (struct skcipher_request *req) { -struct rctx *rctx =skcipher_request_ctx (req); +struct lrw_request_ctx *rctx =skcipher_request_ctx (req);struct skcipher_request *subreq = &rctx->subreq; -init_crypt (req); -return xor_tweak_pre (req) ?: +lrw_init_crypt (req); +return lrw_xor_tweak_pre (req) ?:crypto_skcipher_decrypt (subreq) ?: -xor_tweak_post (req); +lrw_xor_tweak_post (req); } -static int init_tfm (struct crypto_skcipher *tfm) +static int lrw_init_tfm (struct crypto_skcipher *tfm) {struct skcipher_instance *inst =skcipher_alg_instance (tfm);struct crypto_skcipher_spawn *spawn =skcipher_instance_ctx (inst); -struct priv *ctx =crypto_skcipher_ctx (tfm); +struct lrw_tfm_ctx *ctx =crypto_skcipher_ctx (tfm);struct crypto_skcipher *cipher; cipher =crypto_spawn_skcipher (spawn);
@@ -273,27 +276,27 @@ static int init_tfm(struct crypto_skcipher *tfm) ctx->child = cipher;crypto_skcipher_set_reqsize (tfm,crypto_skcipher_reqsize (cipher) + -sizeof (struct rctx )); +sizeof (struct lrw_request_ctx ));return 0 ; } -static void exit_tfm (struct crypto_skcipher *tfm) +static void lrw_exit_tfm (struct crypto_skcipher *tfm) { -struct priv *ctx =crypto_skcipher_ctx (tfm); +struct lrw_tfm_ctx *ctx =crypto_skcipher_ctx (tfm);if (ctx->table)gf128mul_free_64k (ctx->table);crypto_free_skcipher (ctx->child); } -static void crypto_lrw_free (struct skcipher_instance *inst) +static void lrw_free_instance (struct skcipher_instance *inst) {crypto_drop_skcipher (skcipher_instance_ctx (inst));kfree (inst); } -static int create (struct crypto_template *tmpl,struct rtattr **tb) +static int lrw_create (struct crypto_template *tmpl,struct rtattr **tb) {struct crypto_skcipher_spawn *spawn;struct skcipher_instance *inst;
@@ -384,43 +387,43 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb) inst->alg.max_keysize =crypto_skcipher_alg_max_keysize (alg) +LRW_BLOCK_SIZE ; - inst->alg.base.cra_ctxsize =sizeof (struct priv ); + inst->alg.base.cra_ctxsize =sizeof (struct lrw_tfm_ctx ); - inst->alg.init = init_tfm; - inst->alg.exit = exit_tfm; + inst->alg.init = lrw_init_tfm; + inst->alg.exit = lrw_exit_tfm; - inst->alg.setkey = setkey; - inst->alg.encrypt = encrypt; - inst->alg.decrypt = decrypt; + inst->alg.setkey = lrw_setkey; + inst->alg.encrypt = lrw_encrypt; + inst->alg.decrypt = lrw_decrypt; - inst->free = crypto_lrw_free; + inst->free = lrw_free_instance; err =skcipher_register_instance (tmpl, inst);if (err) { err_free_inst: -crypto_lrw_free (inst); +lrw_free_instance (inst); }return err; } -static struct crypto_template crypto_tmpl = { +static struct crypto_template lrw_tmpl = { .name ="lrw" , - .create = create, + .create = lrw_create, .module =THIS_MODULE , }; -static int __init crypto_module_init (void ) +static int __init lrw_module_init (void ) { -return crypto_register_template (&crypto_tmpl); +return crypto_register_template (&lrw_tmpl); } -static void __exit crypto_module_exit(void) +static void __exit lrw_module_exit(void) { -crypto_unregister_template (&crypto_tmpl); +crypto_unregister_template (&lrw_tmpl); } -subsys_initcall (crypto_module_init); -module_exit (crypto_module_exit); +subsys_initcall (lrw_module_init); +module_exit (lrw_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("LRW block cipher mode" );
Signature · 1 line
2.27.0
Herbert Xu
maintainerQuoted 8 lines · Eric Biggers
From: Eric Biggers <[email protected]>
Overly-generic names can cause problems like naming collisions, confusing crash reports, and reduced grep-ability. E.g. see commit
d099ea6e6fde("crypto - Avoidfree()namespace collision").Clean this up for the lrw template by prefixing the names with "
lrw_".
Quoted 8 lines
(I didn't use "
crypto_lrw_" instead because that seems overkill.)Also constify the tfm context in a couple places.
Signed-off-by Eric Biggers <[email protected]>---
crypto/lrw.c| 119 ++++++++++++++++++++++++++-------------------------1 file changed, 61 insertions(+), 58 deletions(-)
Patch applied. Thanks.
Signature · 3 lines
Email: Herbert Xu <[email protected]> Home Page: http://gondor.apana.org.au/~herbert/ PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt