crypto: Remove request chaining
Subsystems (2)
Herbert Xu
maintainerv2 cover crypto: Remove request chaining
v2 rebases on top of the ahash chain disabling patch for stable.
This series removes request chaining from acomp and ahash.
Herbert Xu (5):
Revert "crypto: testmgr - Add multibuffer acomp testing"
crypto: deflate - Remove request chaining
crypto: acomp - Remove request chaining
Revert "crypto: tcrypt - Restore multibuffer ahash tests"
crypto: ahash - Remove request chaining
crypto/acompress.c | 117 ++++---------- crypto/ahash.c | 169 ++++---------------- crypto/deflate.c | 14 -- crypto/scompress.c | 18 +-- crypto/tcrypt.c | 231 ---------------------------- crypto/testmgr.c | 145 ++++++++--------- include/crypto/acompress.h | 14 -- include/crypto/algapi.h | 5 - include/crypto/hash.h | 12 -- include/crypto/internal/acompress.h | 5 - include/crypto/internal/hash.h | 5 - include/linux/crypto.h | 15 -- 12 files changed, 130 insertions(+), 620 deletions(-)
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH v2 1/5 Revert "crypto: testmgr - Add multibuffer acomp testing"
This reverts commit 99585c2192cb1ce212876e82ef01d1c98c7f4699.
Remove the acomp multibuffer tests so that the interface can be redesigned.
--- crypto/testmgr.c | 145 ++++++++++++++++++++--------------------------- 1 file changed, 63 insertions(+), 82 deletions(-)
crypto/testmgr.c +63 -82
@@ -58,9 +58,6 @@ module_param(fuzz_iterations, uint, 0644);MODULE_PARM_DESC (fuzz_iterations,"number of fuzz test iterations" );#endif -/* Multibuffer is unlimited. Set arbitrary limit for testing. */ -#define MAX_MB_MSGS 16 -#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS /* a perfect nop */
@@ -3329,48 +3326,27 @@ static int test_acomp(struct crypto_acomp *tfm, int ctcount, int dtcount) {const char *algo =crypto_tfm_alg_driver_name (crypto_acomp_tfm (tfm)); -struct scatterlist *src =NULL , *dst =NULL ; -struct acomp_req *reqs[MAX_MB_MSGS ] = {}; -char *decomp_out[MAX_MB_MSGS ] = {}; -char *output[MAX_MB_MSGS ] = {}; -struct crypto_wait wait; -struct acomp_req *req; -int ret = -ENOMEM ;unsigned int i; +char *output, *decomp_out; +int ret; +struct scatterlist src, dst; +struct acomp_req *req; +struct crypto_wait wait; - src =kmalloc_array (MAX_MB_MSGS ,sizeof (*src),GFP_KERNEL ); -if (!src) - goto out; - dst =kmalloc_array (MAX_MB_MSGS ,sizeof (*dst),GFP_KERNEL ); -if (!dst) - goto out; + output =kmalloc (COMP_BUF_SIZE ,GFP_KERNEL ); +if (!output) +return -ENOMEM ; -for (i =0 ; i <MAX_MB_MSGS ; i++) { - reqs[i] =acomp_request_alloc (tfm); -if (!reqs[i]) - goto out; - -acomp_request_set_callback (reqs[i], -CRYPTO_TFM_REQ_MAY_SLEEP | -CRYPTO_TFM_REQ_MAY_BACKLOG , - crypto_req_done, &wait); -if (i) -acomp_request_chain (reqs[i], reqs[0 ]); - - output[i] =kmalloc (COMP_BUF_SIZE ,GFP_KERNEL ); -if (!output[i]) - goto out; - - decomp_out[i] =kmalloc (COMP_BUF_SIZE ,GFP_KERNEL ); -if (!decomp_out[i]) - goto out; + decomp_out =kmalloc (COMP_BUF_SIZE ,GFP_KERNEL ); +if (!decomp_out) { +kfree (output); +return -ENOMEM ; }for (i =0 ; i < ctcount; i++) {unsigned int dlen =COMP_BUF_SIZE ;int ilen = ctemplate[i].inlen;void *input_vec; -int j; input_vec =kmemdup (ctemplate[i].input, ilen,GFP_KERNEL );if (!input_vec) {
@@ -3378,61 +3354,70 @@ static int test_acomp(struct crypto_acomp *tfm, goto out; } +memset (output,0 , dlen);crypto_init_wait (&wait); -sg_init_one (src, input_vec, ilen); +sg_init_one (&src, input_vec, ilen); +sg_init_one (&dst, output, dlen); -for (j =0 ; j <MAX_MB_MSGS ; j++) { -sg_init_one (dst + j, output[j], dlen); -acomp_request_set_params (reqs[j], src, dst + j, ilen, dlen); + req =acomp_request_alloc (tfm); +if (!req) { +pr_err ("alg: acomp: request alloc failed for %s\n" , + algo); +kfree (input_vec); + ret = -ENOMEM ; + goto out; } - req = reqs[0 ]; +acomp_request_set_params (req, &src, &dst, ilen, dlen); +acomp_request_set_callback (req,CRYPTO_TFM_REQ_MAY_BACKLOG , + crypto_req_done, &wait); + ret =crypto_wait_req (crypto_acomp_compress (req), &wait);if (ret) {pr_err ("alg: acomp: compression failed on test %d for %s: ret=%d\n" , i +1 , algo, -ret);kfree (input_vec); +acomp_request_free (req); goto out; } ilen = req->dlen; dlen =COMP_BUF_SIZE ; +sg_init_one (&src, output, ilen); +sg_init_one (&dst, decomp_out, dlen);crypto_init_wait (&wait); -for (j =0 ; j <MAX_MB_MSGS ; j++) { -sg_init_one (src + j, output[j], ilen); -sg_init_one (dst + j, decomp_out[j], dlen); -acomp_request_set_params (reqs[j], src + j, dst + j, ilen, dlen); +acomp_request_set_params (req, &src, &dst, ilen, dlen); + + ret =crypto_wait_req (crypto_acomp_decompress (req), &wait); +if (ret) { +pr_err ("alg: acomp: compression failed on test %d for %s: ret=%d\n" , + i +1 , algo, -ret); +kfree (input_vec); +acomp_request_free (req); + goto out; } -crypto_wait_req (crypto_acomp_decompress (req), &wait); -for (j =0 ; j <MAX_MB_MSGS ; j++) { - ret = reqs[j]->base.err; -if (ret) { -pr_err ("alg: acomp: compression failed on test %d (%d) for %s: ret=%d\n" , - i +1 , j, algo, -ret); -kfree (input_vec); - goto out; - } +if (req->dlen != ctemplate[i].inlen) { +pr_err ("alg: acomp: Compression test %d failed for %s: output len = %d\n" , + i +1 , algo, req->dlen); + ret = -EINVAL ; +kfree (input_vec); +acomp_request_free (req); + goto out; + } -if (reqs[j]->dlen != ctemplate[i].inlen) { -pr_err ("alg: acomp: Compression test %d (%d) failed for %s: output len = %d\n" , - i +1 , j, algo, reqs[j]->dlen); - ret = -EINVAL ; -kfree (input_vec); - goto out; - } - -if (memcmp (input_vec, decomp_out[j], reqs[j]->dlen)) { -pr_err ("alg: acomp: Compression test %d (%d) failed for %s\n" , - i +1 , j, algo); -hexdump (output[j], reqs[j]->dlen); - ret = -EINVAL ; -kfree (input_vec); - goto out; - } +if (memcmp (input_vec, decomp_out, req->dlen)) { +pr_err ("alg: acomp: Compression test %d failed for %s\n" , + i +1 , algo); +hexdump (output, req->dlen); + ret = -EINVAL ; +kfree (input_vec); +acomp_request_free (req); + goto out; }kfree (input_vec); +acomp_request_free (req); }for (i =0 ; i < dtcount; i++) {
@@ -3446,9 +3431,10 @@ static int test_acomp(struct crypto_acomp *tfm, goto out; } +memset (output,0 , dlen);crypto_init_wait (&wait); -sg_init_one (src, input_vec, ilen); -sg_init_one (dst, output[0 ], dlen); +sg_init_one (&src, input_vec, ilen); +sg_init_one (&dst, output, dlen); req =acomp_request_alloc (tfm);if (!req) {
@@ -3459,7 +3445,7 @@ static int test_acomp(struct crypto_acomp *tfm, goto out; } -acomp_request_set_params (req, src, dst, ilen, dlen); +acomp_request_set_params (req, &src, &dst, ilen, dlen);acomp_request_set_callback (req,CRYPTO_TFM_REQ_MAY_BACKLOG , crypto_req_done, &wait);
@@ -3481,10 +3467,10 @@ static int test_acomp(struct crypto_acomp *tfm, goto out; } -if (memcmp (output[0 ], dtemplate[i].output, req->dlen)) { +if (memcmp (output, dtemplate[i].output, req->dlen)) {pr_err ("alg: acomp: Decompression test %d failed for %s\n" , i +1 , algo); -hexdump (output[0 ], req->dlen); +hexdump (output, req->dlen); ret = -EINVAL ;kfree (input_vec);acomp_request_free (req);
@@ -3498,13 +3484,8 @@ static int test_acomp(struct crypto_acomp *tfm, ret =0 ; out: -acomp_request_free (reqs[0 ]); -for (i =0 ; i <MAX_MB_MSGS ; i++) { -kfree (output[i]); -kfree (decomp_out[i]); - } -kfree (dst); -kfree (src); +kfree (decomp_out); +kfree (output);return ret; }
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH v2 2/5 crypto: deflate - Remove request chaining
In reply to Herbert XuRemove request chaining support from deflate.
--- crypto/deflate.c | 14 -------------- 1 file changed, 14 deletions(-)
crypto/deflate.c +0 -14
@@ -111,7 +111,6 @@ static int deflate_compress(struct acomp_req *req) {struct crypto_acomp_stream *s;struct deflate_stream *ds; -struct acomp_req *r2;int err; s =crypto_acomp_lock_stream_bh (&deflate_streams);
@@ -126,12 +125,6 @@ static int deflate_compress(struct acomp_req *req) } err =deflate_compress_one (req, ds); - req->base.err = err; - -list_for_each_entry (r2, &req->base.list, base.list) { -zlib_deflateReset (&ds->stream); - r2->base.err =deflate_compress_one (r2, ds); - } out:crypto_acomp_unlock_stream_bh (s);
@@ -199,7 +192,6 @@ static int deflate_decompress(struct acomp_req *req) {struct crypto_acomp_stream *s;struct deflate_stream *ds; -struct acomp_req *r2;int err; s =crypto_acomp_lock_stream_bh (&deflate_streams);
@@ -212,12 +204,6 @@ static int deflate_decompress(struct acomp_req *req) } err =deflate_decompress_one (req, ds); - req->base.err = err; - -list_for_each_entry (r2, &req->base.list, base.list) { -zlib_inflateReset (&ds->stream); - r2->base.err =deflate_decompress_one (r2, ds); - } out:crypto_acomp_unlock_stream_bh (s);
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH v2 3/5 crypto: acomp - Remove request chaining
In reply to Herbert XuRequest chaining requires the user to do too much book keeping. Remove it from acomp.
--- crypto/acompress.c | 117 ++++++++-------------------- crypto/scompress.c | 18 +---- include/crypto/acompress.h | 14 ---- include/crypto/internal/acompress.h | 5 -- 4 files changed, 35 insertions(+), 119 deletions(-)
crypto/acompress.c +33 -84
@@ -178,7 +178,6 @@ static void acomp_save_req(struct acomp_req *req, crypto_completion_t cplt) state->data = req->base.data; req->base.complete = cplt; req->base.data = state; - state->req0 = req; }static void acomp_restore_req (struct acomp_req *req)
@@ -189,23 +188,20 @@ static void acomp_restore_req(struct acomp_req *req) req->base.data = state->data; } -static void acomp_reqchain_virt (struct acomp_req_chain *state,int err) +static void acomp_reqchain_virt (struct acomp_req *req) { -struct acomp_req *req = state->cur; +struct acomp_req_chain *state = &req->chain;unsigned int slen = req->slen;unsigned int dlen = req->dlen; - req->base.err = err; - state = &req->chain; -if (state->flags &CRYPTO_ACOMP_REQ_SRC_VIRT )acomp_request_set_src_dma (req, state->src, slen);else if (state->flags &CRYPTO_ACOMP_REQ_SRC_FOLIO ) -acomp_request_set_src_folio (req, state->sfolio, state->soff, slen); +acomp_request_set_src_folio (req, state->sfolio, req->soff, slen);if (state->flags &CRYPTO_ACOMP_REQ_DST_VIRT )acomp_request_set_dst_dma (req, state->dst, dlen);else if (state->flags &CRYPTO_ACOMP_REQ_DST_FOLIO ) -acomp_request_set_dst_folio (req, state->dfolio, state->doff, dlen); +acomp_request_set_dst_folio (req, state->dfolio, req->doff, dlen); }static void acomp_virt_to_sg (struct acomp_req *req)
@@ -230,7 +226,6 @@ static void acomp_virt_to_sg(struct acomp_req *req)size_t off = req->soff; state->sfolio = folio; - state->soff = off;sg_init_table (&state->ssg,1 );sg_set_page (&state->ssg,folio_page (folio, off /PAGE_SIZE ), slen, off %PAGE_SIZE );
@@ -250,7 +245,6 @@ static void acomp_virt_to_sg(struct acomp_req *req)size_t off = req->doff; state->dfolio = folio; - state->doff = off;sg_init_table (&state->dsg,1 );sg_set_page (&state->dsg,folio_page (folio, off /PAGE_SIZE ), dlen, off %PAGE_SIZE );
@@ -258,8 +252,7 @@ static void acomp_virt_to_sg(struct acomp_req *req) } } -static int acomp_do_nondma (struct acomp_req_chain *state, -struct acomp_req *req) +static int acomp_do_nondma (struct acomp_req *req,bool comp) {u32 keep =CRYPTO_ACOMP_REQ_SRC_VIRT | CRYPTO_ACOMP_REQ_SRC_NONDMA |
@@ -276,7 +269,7 @@ static int acomp_do_nondma(struct acomp_req_chain *state, fbreq->slen = req->slen; fbreq->dlen = req->dlen; -if (state->op ==crypto_acomp_reqtfm (req)->compress) +if (comp) err =crypto_acomp_compress (fbreq);else err =crypto_acomp_decompress (fbreq);
@@ -285,114 +278,70 @@ static int acomp_do_nondma(struct acomp_req_chain *state,return err; } -static int acomp_do_one_req (struct acomp_req_chain *state, -struct acomp_req *req) +static int acomp_do_one_req (struct acomp_req *req,bool comp) { - state->cur = req; -if (acomp_request_isnondma (req)) -return acomp_do_nondma (state, req); +return acomp_do_nondma (req, comp);acomp_virt_to_sg (req); -return state->op (req); +return comp ?crypto_acomp_reqtfm (req)->compress (req) : +crypto_acomp_reqtfm (req)->decompress (req); } -static int acomp_reqchain_finish (struct acomp_req *req0,int err,u32 mask) +static int acomp_reqchain_finish (struct acomp_req *req,int err) { -struct acomp_req_chain *state = req0->base.data; -struct acomp_req *req = state->cur; -struct acomp_req *n; - -acomp_reqchain_virt (state, err); - -if (req != req0) -list_add_tail (&req->base.list, &req0->base.list); - -list_for_each_entry_safe (req, n, &state->head, base.list) { -list_del_init (&req->base.list); - - req->base.flags &= mask; - req->base.complete = acomp_reqchain_done; - req->base.data = state; - - err =acomp_do_one_req (state, req); - -if (err == -EINPROGRESS ) { -if (!list_empty (&state->head)) - err = -EBUSY ; - goto out; - } - -if (err == -EBUSY ) - goto out; - -acomp_reqchain_virt (state, err); -list_add_tail (&req->base.list, &req0->base.list); - } - -acomp_restore_req (req0); - -out: +acomp_reqchain_virt (req); +acomp_restore_req (req);return err; }static void acomp_reqchain_done (void *data,int err) { -struct acomp_req_chain *state = data; -crypto_completion_t compl = state->compl; +struct acomp_req *req = data; +crypto_completion_t compl; - data = state->data; + compl = req->chain.compl; + data = req->chain.data; -if (err == -EINPROGRESS ) { -if (!list_empty (&state->head)) -return ; +if (err == -EINPROGRESS ) goto notify; - } - err =acomp_reqchain_finish (state->req0, err, -CRYPTO_TFM_REQ_MAY_BACKLOG ); -if (err == -EBUSY ) -return ; + err =acomp_reqchain_finish (req, err); notify:compl (data, err); } -static int acomp_do_req_chain (struct acomp_req *req, -int (*op)(struct acomp_req *req)) +static int acomp_do_req_chain (struct acomp_req *req,bool comp) { -struct crypto_acomp *tfm =crypto_acomp_reqtfm (req); -struct acomp_req_chain *state;int err; -if (crypto_acomp_req_chain (tfm) || - (!acomp_request_chained (req) &&acomp_request_issg (req))) -return op (req); -acomp_save_req (req, acomp_reqchain_done); - state = req->base.data; - state->op = op; - state->src =NULL ; -INIT_LIST_HEAD (&state->head); -list_splice_init (&req->base.list, &state->head); - - err =acomp_do_one_req (state, req); + err =acomp_do_one_req (req, comp);if (err == -EBUSY || err == -EINPROGRESS ) -return -EBUSY ; +return err; -return acomp_reqchain_finish (req, err, ~0 ); +return acomp_reqchain_finish (req, err); }int crypto_acomp_compress (struct acomp_req *req) { -return acomp_do_req_chain (req,crypto_acomp_reqtfm (req)->compress); +struct crypto_acomp *tfm =crypto_acomp_reqtfm (req); + +if (crypto_acomp_req_chain (tfm) ||acomp_request_issg (req)) +crypto_acomp_reqtfm (req)->compress (req); +return acomp_do_req_chain (req, true); }EXPORT_SYMBOL_GPL (crypto_acomp_compress);int crypto_acomp_decompress (struct acomp_req *req) { -return acomp_do_req_chain (req,crypto_acomp_reqtfm (req)->decompress); +struct crypto_acomp *tfm =crypto_acomp_reqtfm (req); + +if (crypto_acomp_req_chain (tfm) ||acomp_request_issg (req)) +crypto_acomp_reqtfm (req)->decompress (req); +return acomp_do_req_chain (req, false); }EXPORT_SYMBOL_GPL (crypto_acomp_decompress);
crypto/scompress.c +2 -16
@@ -284,28 +284,14 @@ static int scomp_acomp_comp_decomp(struct acomp_req *req, int dir)return ret; } -static int scomp_acomp_chain (struct acomp_req *req,int dir) -{ -struct acomp_req *r2; -int err; - - err =scomp_acomp_comp_decomp (req, dir); - req->base.err = err; - -list_for_each_entry (r2, &req->base.list, base.list) - r2->base.err =scomp_acomp_comp_decomp (r2, dir); - -return err; -} -static int scomp_acomp_compress (struct acomp_req *req) { -return scomp_acomp_chain (req,1 ); +return scomp_acomp_comp_decomp (req,1 ); }static int scomp_acomp_decompress (struct acomp_req *req) { -return scomp_acomp_chain (req,0 ); +return scomp_acomp_comp_decomp (req,0 ); }static void crypto_exit_scomp_ops_async (struct crypto_tfm *tfm)
include/crypto/acompress.h +0 -14
@@ -52,10 +52,6 @@ struct acomp_req;struct folio ;struct acomp_req_chain { -struct list_head head; -struct acomp_req *req0; -struct acomp_req *cur; -int (*op)(struct acomp_req *req);crypto_completion_t compl;void *data;struct scatterlist ssg;
@@ -68,8 +64,6 @@ struct acomp_req_chain {u8 *dst;struct folio *dfolio; }; -size_t soff; -size_t doff;u32 flags; };
@@ -343,8 +337,6 @@ static inline void acomp_request_set_callback(struct acomp_req *req, req->base.data = data; req->base.flags &= keep; req->base.flags |= flgs & ~keep; - -crypto_reqchain_init (&req->base); }/**
@@ -552,12 +544,6 @@ static inline void acomp_request_set_dst_folio(struct acomp_req *req, req->base.flags |=CRYPTO_ACOMP_REQ_DST_FOLIO ; } -static inline void acomp_request_chain (struct acomp_req *req, -struct acomp_req *head) -{ -crypto_request_chain (&req->base, &head->base); -} -/** * crypto_acomp_compress() -- Invoke asynchronous compress operation *
include/crypto/internal/acompress.h +0 -5
@@ -151,11 +151,6 @@ void crypto_unregister_acomp(struct acomp_alg *alg);int crypto_register_acomps (struct acomp_alg *algs,int count);void crypto_unregister_acomps (struct acomp_alg *algs,int count); -static inline bool acomp_request_chained (struct acomp_req *req) -{ -return crypto_request_chained (&req->base); -} -static inline bool acomp_request_issg (struct acomp_req *req) { return !(req->base.flags & (CRYPTO_ACOMP_REQ_SRC_VIRT |
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH v2 4/5 Revert "crypto: tcrypt - Restore multibuffer ahash tests"
In reply to Herbert XuThis reverts commit c664f034172705a75f3f8a0c409b9bf95b633093.
Remove the multibuffer ahash speed tests again.
--- crypto/tcrypt.c | 231 ------------------------------------------------ 1 file changed, 231 deletions(-)
crypto/tcrypt.c +0 -231
@@ -716,207 +716,6 @@ static inline int do_one_ahash_op(struct ahash_request *req, int ret)return crypto_wait_req (ret, wait); } -struct test_mb_ahash_data { -struct scatterlist sg[XBUFSIZE ]; -char result[64 ]; -struct ahash_request *req; -struct crypto_wait wait; -char *xbuf[XBUFSIZE ]; -}; - -static inline int do_mult_ahash_op (struct test_mb_ahash_data *data,u32 num_mb, -int *rc) -{ -int i, err; - -/* Fire up a bunch of concurrent requests */ - err =crypto_ahash_digest (data[0 ].req); - -/* Wait for all requests to finish */ - err =crypto_wait_req (err, &data[0 ].wait); -if (num_mb <2 ) -return err; - -for (i =0 ; i < num_mb; i++) { - rc[i] =ahash_request_err (data[i].req); -if (rc[i]) { -pr_info ("concurrent request %d error %d\n" , i, rc[i]); - err = rc[i]; - } - } - -return err; -} - -static int test_mb_ahash_jiffies (struct test_mb_ahash_data *data,int blen, -int secs,u32 num_mb) -{ -unsigned long start, end; -int bcount; -int ret =0 ; -int *rc; - - rc =kcalloc (num_mb,sizeof (*rc),GFP_KERNEL ); -if (!rc) -return -ENOMEM ; - -for (start = jiffies, end = start + secs *HZ , bcount =0 ; -time_before (jiffies, end); bcount++) { - ret =do_mult_ahash_op (data, num_mb, rc); -if (ret) - goto out; - } - -pr_cont ("%d operations in %d seconds (%llu bytes)\n" , - bcount * num_mb, secs, (u64 )bcount * blen * num_mb); - -out: -kfree (rc); -return ret; -} - -static int test_mb_ahash_cycles (struct test_mb_ahash_data *data,int blen, -u32 num_mb) -{ -unsigned long cycles =0 ; -int ret =0 ; -int i; -int *rc; - - rc =kcalloc (num_mb,sizeof (*rc),GFP_KERNEL ); -if (!rc) -return -ENOMEM ; - -/* Warm-up run. */ -for (i =0 ; i <4 ; i++) { - ret =do_mult_ahash_op (data, num_mb, rc); -if (ret) - goto out; - } - -/* The real thing. */ -for (i =0 ; i <8 ; i++) { -cycles_t start, end; - - start =get_cycles (); - ret =do_mult_ahash_op (data, num_mb, rc); - end =get_cycles (); - -if (ret) - goto out; - - cycles += end - start; - } - -pr_cont ("1 operation in %lu cycles (%d bytes)\n" , - (cycles +4 ) / (8 * num_mb), blen); - -out: -kfree (rc); -return ret; -} - -static void test_mb_ahash_speed (const char *algo,unsigned int secs, -struct hash_speed *speed,u32 num_mb) -{ -struct test_mb_ahash_data *data; -struct crypto_ahash *tfm; -unsigned int i, j, k; -int ret; - - data =kcalloc (num_mb,sizeof (*data),GFP_KERNEL ); -if (!data) -return ; - - tfm =crypto_alloc_ahash (algo,0 ,0 ); -if (IS_ERR (tfm)) { -pr_err ("failed to load transform for %s: %ld\n" , - algo,PTR_ERR (tfm)); - goto free_data; - } - -for (i =0 ; i < num_mb; ++i) { -if (testmgr_alloc_buf (data[i].xbuf)) - goto out; - -crypto_init_wait (&data[i].wait); - - data[i].req =ahash_request_alloc (tfm,GFP_KERNEL ); -if (!data[i].req) { -pr_err ("alg: hash: Failed to allocate request for %s\n" , - algo); - goto out; - } - - -if (i) { -ahash_request_set_callback (data[i].req,0 ,NULL ,NULL ); -ahash_request_chain (data[i].req, data[0 ].req); - }else -ahash_request_set_callback (data[0 ].req,0 , - crypto_req_done, - &data[0 ].wait); - -sg_init_table (data[i].sg,XBUFSIZE ); -for (j =0 ; j <XBUFSIZE ; j++) { -sg_set_buf (data[i].sg + j, data[i].xbuf[j],PAGE_SIZE ); -memset (data[i].xbuf[j],0xff ,PAGE_SIZE ); - } - } - -pr_info ("\ntesting speed of multibuffer %s (%s)\n" , algo, -get_driver_name (crypto_ahash, tfm)); - -for (i =0 ; speed[i].blen !=0 ; i++) { -/* For some reason this only tests digests. */ -if (speed[i].blen != speed[i].plen) -continue ; - -if (speed[i].blen >XBUFSIZE *PAGE_SIZE ) { -pr_err ("template (%u) too big for tvmem (%lu)\n" , - speed[i].blen,XBUFSIZE *PAGE_SIZE ); - goto out; - } - -if (klen) -crypto_ahash_setkey (tfm, tvmem[0 ], klen); - -for (k =0 ; k < num_mb; k++) -ahash_request_set_crypt (data[k].req, data[k].sg, - data[k].result, speed[i].blen); - -pr_info ("test%3u " -"(%5u byte blocks,%5u bytes per update,%4u updates): " , - i, speed[i].blen, speed[i].plen, - speed[i].blen / speed[i].plen); - -if (secs) { - ret =test_mb_ahash_jiffies (data, speed[i].blen, secs, - num_mb); -cond_resched (); - }else { - ret =test_mb_ahash_cycles (data, speed[i].blen, num_mb); - } - - -if (ret) { -pr_err ("At least one hashing failed ret=%d\n" , ret); -break ; - } - } - -out: -ahash_request_free (data[0 ].req); - -for (k =0 ; k < num_mb; ++k) -testmgr_free_buf (data[k].xbuf); - -crypto_free_ahash (tfm); - -free_data: -kfree (data); -} -static int test_ahash_jiffies_digest (struct ahash_request *req,int blen,char *out,int secs) {
@@ -2584,36 +2383,6 @@ static int do_test(const char *alg, u32 type, u32 mask, int m, u32 num_mb)test_ahash_speed ("sm3" , sec, generic_hash_speed_template);if (mode >400 && mode <500 )break ; fallthrough; -case 450 : -test_mb_ahash_speed ("sha1" , sec, generic_hash_speed_template, - num_mb); -if (mode >400 && mode <500 )break ; - fallthrough; -case 451 : -test_mb_ahash_speed ("sha256" , sec, generic_hash_speed_template, - num_mb); -if (mode >400 && mode <500 )break ; - fallthrough; -case 452 : -test_mb_ahash_speed ("sha512" , sec, generic_hash_speed_template, - num_mb); -if (mode >400 && mode <500 )break ; - fallthrough; -case 453 : -test_mb_ahash_speed ("sm3" , sec, generic_hash_speed_template, - num_mb); -if (mode >400 && mode <500 )break ; - fallthrough; -case 454 : -test_mb_ahash_speed ("streebog256" , sec, - generic_hash_speed_template, num_mb); -if (mode >400 && mode <500 )break ; - fallthrough; -case 455 : -test_mb_ahash_speed ("streebog512" , sec, - generic_hash_speed_template, num_mb); -if (mode >400 && mode <500 )break ; - fallthrough;case 499 :break ;
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH v2 5/5 crypto: ahash - Remove request chaining
In reply to Herbert XuRequest chaining requires the user to do too much book keeping. Remove it from ahash.
--- crypto/ahash.c | 169 +++++++-------------------------- include/crypto/algapi.h | 5 - include/crypto/hash.h | 12 --- include/crypto/internal/hash.h | 5 - include/linux/crypto.h | 15 --- 5 files changed, 32 insertions(+), 174 deletions(-)
crypto/ahash.c +32 -137
@@ -43,10 +43,7 @@ struct crypto_hash_walk { };struct ahash_save_req_state { -struct list_head head;struct ahash_request *req0; -struct ahash_request *cur; -int (*op)(struct ahash_request *req);crypto_completion_t compl;void *data;struct scatterlist sg;
@@ -54,9 +51,9 @@ struct ahash_save_req_state {u8 *page;unsigned int offset;unsigned int nbytes; +bool update; }; -static void ahash_reqchain_done (void *data,int err);static int ahash_save_req (struct ahash_request *req,crypto_completion_t cplt);static void ahash_restore_req (struct ahash_request *req);static void ahash_def_finup_done1 (void *data,int err);
@@ -313,21 +310,17 @@ int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key, }EXPORT_SYMBOL_GPL (crypto_ahash_setkey); -static bool ahash_request_hasvirt (struct ahash_request *req) -{ -return ahash_request_isvirt (req); -} -static int ahash_reqchain_virt (struct ahash_save_req_state *state,int err,u32 mask) { -struct ahash_request *req = state->cur; +struct ahash_request *req = state->req0; +struct crypto_ahash *tfm; + + tfm =crypto_ahash_reqtfm (req);for (;;) {unsigned len = state->nbytes; - req->base.err = err; -if (!state->offset)break ;
@@ -346,10 +339,9 @@ static int ahash_reqchain_virt(struct ahash_save_req_state *state, state->offset += len; req->nbytes = len; - err = state->op (req); + err =crypto_ahash_alg (tfm)->update (req);if (err == -EINPROGRESS ) { -if (!list_empty (&state->head) || - state->offset < state->nbytes) +if (state->offset < state->nbytes) err = -EBUSY ;break ; }
@@ -365,64 +357,12 @@ static int ahash_reqchain_finish(struct ahash_request *req0,struct ahash_save_req_state *state, int err, u32 mask) { - struct ahash_request *req = state->cur; -struct crypto_ahash *tfm; -struct ahash_request *n; -bool update; u8 *page; err =ahash_reqchain_virt (state, err, mask);if (err == -EINPROGRESS || err == -EBUSY ) goto out; -if (req != req0) -list_add_tail (&req->base.list, &req0->base.list); - - tfm =crypto_ahash_reqtfm (req); - update = state->op ==crypto_ahash_alg (tfm)->update; - -list_for_each_entry_safe (req, n, &state->head, base.list) { -list_del_init (&req->base.list); - - req->base.flags &= mask; - req->base.complete = ahash_reqchain_done; - req->base.data = state; - state->cur = req; - -if (update &&ahash_request_isvirt (req) && req->nbytes) { -unsigned len = req->nbytes; -u8 *result = req->result; - - state->src = req->svirt; - state->nbytes = len; - - len =min (PAGE_SIZE , len); - -memcpy (state->page, req->svirt, len); - state->offset = len; - -ahash_request_set_crypt (req, &state->sg, result, len); - } - - err = state->op (req); - -if (err == -EINPROGRESS ) { -if (!list_empty (&state->head) || - state->offset < state->nbytes) - err = -EBUSY ; - goto out; - } - -if (err == -EBUSY ) - goto out; - - err =ahash_reqchain_virt (state, err, mask); -if (err == -EINPROGRESS || err == -EBUSY ) - goto out; - -list_add_tail (&req->base.list, &req0->base.list); - } - page = state->page;if (page) {memset (page,0 ,PAGE_SIZE );
@@ -442,7 +382,7 @@ static void ahash_reqchain_done(void *data, int err) data = state->data;if (err == -EINPROGRESS ) { -if (!list_empty (&state->head) || state->offset < state->nbytes) +if (state->offset < state->nbytes)return ; goto notify; }
@@ -467,21 +407,14 @@ static int ahash_do_req_chain(struct ahash_request *req,int err;if (crypto_ahash_req_chain (tfm) || - (!ahash_request_chained (req) && - (!update || !ahash_request_isvirt (req)))) + !update || !ahash_request_isvirt (req))return op (req); -if (update &&ahash_request_hasvirt (req)) { -gfp_t gfp; -u32 flags; - - flags =ahash_request_flags (req); - gfp = (flags &CRYPTO_TFM_REQ_MAY_SLEEP ) ? -GFP_KERNEL :GFP_ATOMIC ; - page = (void *)__get_free_page (gfp); +if (update &&ahash_request_isvirt (req)) { + page = (void *)__get_free_page (GFP_ATOMIC ); err = -ENOMEM ;if (!page) - goto out_set_chain; + goto out; } state = &state0;
@@ -493,12 +426,10 @@ static int ahash_do_req_chain(struct ahash_request *req, state = req->base.data; } - state->op = op; - state->cur = req; + state->update = update; state->page = page; state->offset =0 ; state->nbytes =0 ; -INIT_LIST_HEAD (&state->head);if (page)sg_init_one (&state->sg, page,PAGE_SIZE );
@@ -519,16 +450,18 @@ static int ahash_do_req_chain(struct ahash_request *req, } err =op (req); -if (err == -EBUSY || err == -EINPROGRESS ) -return -EBUSY ; +if (err == -EINPROGRESS || err == -EBUSY ) { +if (state->offset < state->nbytes) + err = -EBUSY ; +return err; + }return ahash_reqchain_finish (req, state, err, ~0 ); out_free_page:free_page ((unsigned long )page); -out_set_chain: - req->base.err = err; +out:return err; }
@@ -536,17 +469,10 @@ int crypto_ahash_init(struct ahash_request *req) {struct crypto_ahash *tfm =crypto_ahash_reqtfm (req); -if (likely (tfm->using_shash)) { -int err; - - err =crypto_shash_init (prepare_shash_desc (req, tfm)); - req->base.err = err; -return err; - } - +if (likely (tfm->using_shash)) +return crypto_shash_init (prepare_shash_desc (req, tfm));if (crypto_ahash_get_flags (tfm) &CRYPTO_TFM_NEED_KEY )return -ENOKEY ; -return ahash_do_req_chain (req,crypto_ahash_alg (tfm)->init); }EXPORT_SYMBOL_GPL (crypto_ahash_init);
@@ -555,15 +481,11 @@ static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt) {struct crypto_ahash *tfm =crypto_ahash_reqtfm (req);struct ahash_save_req_state *state; -gfp_t gfp; -u32 flags;if (!ahash_is_async (tfm))return 0 ; - flags =ahash_request_flags (req); - gfp = (flags &CRYPTO_TFM_REQ_MAY_SLEEP ) ?GFP_KERNEL :GFP_ATOMIC ; - state =kmalloc (sizeof (*state), gfp); + state =kmalloc (sizeof (*state),GFP_ATOMIC );if (!state)return -ENOMEM ;
@@ -596,14 +518,8 @@ int crypto_ahash_update(struct ahash_request *req) {struct crypto_ahash *tfm =crypto_ahash_reqtfm (req); -if (likely (tfm->using_shash)) { -int err; - - err =shash_ahash_update (req,ahash_request_ctx (req)); - req->base.err = err; -return err; - } - +if (likely (tfm->using_shash)) +return shash_ahash_update (req,ahash_request_ctx (req));return ahash_do_req_chain (req,crypto_ahash_alg (tfm)->update); }EXPORT_SYMBOL_GPL (crypto_ahash_update);
@@ -612,14 +528,8 @@ int crypto_ahash_final(struct ahash_request *req) {struct crypto_ahash *tfm =crypto_ahash_reqtfm (req); -if (likely (tfm->using_shash)) { -int err; - - err =crypto_shash_final (ahash_request_ctx (req), req->result); - req->base.err = err; -return err; - } - +if (likely (tfm->using_shash)) +return crypto_shash_final (ahash_request_ctx (req), req->result);return ahash_do_req_chain (req,crypto_ahash_alg (tfm)->final); }EXPORT_SYMBOL_GPL (crypto_ahash_final);
@@ -628,18 +538,11 @@ int crypto_ahash_finup(struct ahash_request *req) {struct crypto_ahash *tfm =crypto_ahash_reqtfm (req); -if (likely (tfm->using_shash)) { -int err; - - err =shash_ahash_finup (req,ahash_request_ctx (req)); - req->base.err = err; -return err; - } - +if (likely (tfm->using_shash)) +return shash_ahash_finup (req,ahash_request_ctx (req));if (!crypto_ahash_alg (tfm)->finup || - (!crypto_ahash_req_chain (tfm) &&ahash_request_hasvirt (req))) + (!crypto_ahash_req_chain (tfm) &&ahash_request_isvirt (req)))return ahash_def_finup (req); -return ahash_do_req_chain (req,crypto_ahash_alg (tfm)->finup); }EXPORT_SYMBOL_GPL (crypto_ahash_finup);
@@ -706,20 +609,12 @@ int crypto_ahash_digest(struct ahash_request *req) {struct crypto_ahash *tfm =crypto_ahash_reqtfm (req); -if (likely (tfm->using_shash)) { -int err; - - err =shash_ahash_digest (req,prepare_shash_desc (req, tfm)); - req->base.err = err; -return err; - } - -if (!crypto_ahash_req_chain (tfm) &&ahash_request_hasvirt (req)) +if (likely (tfm->using_shash)) +return shash_ahash_digest (req,prepare_shash_desc (req, tfm)); +if (!crypto_ahash_req_chain (tfm) &&ahash_request_isvirt (req))return ahash_def_digest (req); -if (crypto_ahash_get_flags (tfm) &CRYPTO_TFM_NEED_KEY )return -ENOKEY ; -return ahash_do_req_chain (req,crypto_ahash_alg (tfm)->digest); }EXPORT_SYMBOL_GPL (crypto_ahash_digest);
include/crypto/algapi.h +0 -5
@@ -267,11 +267,6 @@ static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)return tfm->__crt_alg->cra_flags &CRYPTO_ALG_TYPE_MASK ; } -static inline bool crypto_request_chained (struct crypto_async_request *req) -{ -return !list_empty (&req->list); -} -static inline bool crypto_tfm_req_chain (struct crypto_tfm *tfm) {return tfm->__crt_alg->cra_flags &CRYPTO_ALG_REQ_CHAIN ;
include/crypto/hash.h +0 -12
@@ -630,7 +630,6 @@ static inline void ahash_request_set_callback(struct ahash_request *req, flags &= ~keep; req->base.flags &= keep; req->base.flags |= flags; -crypto_reqchain_init (&req->base); }/**
@@ -679,12 +678,6 @@ static inline void ahash_request_set_virt(struct ahash_request *req, req->base.flags |=CRYPTO_AHASH_REQ_VIRT ; } -static inline void ahash_request_chain (struct ahash_request *req, -struct ahash_request *head) -{ -crypto_request_chain (&req->base, &head->base); -} -/** * DOC: Synchronous Message Digest API *
@@ -986,11 +979,6 @@ static inline void shash_desc_zero(struct shash_desc *desc) sizeof(*desc) + crypto_shash_descsize(desc->tfm)); } -static inline int ahash_request_err (struct ahash_request *req) -{ -return req->base.err; -} -static inline bool ahash_is_async (struct crypto_ahash *tfm) {return crypto_tfm_is_async (&tfm->base);
include/crypto/internal/hash.h +0 -5
@@ -247,11 +247,6 @@ static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm) return container_of(tfm, struct crypto_shash, base); } -static inline bool ahash_request_chained (struct ahash_request *req) -{ -return false; -} -static inline bool ahash_request_isvirt (struct ahash_request *req) {return req->base.flags &CRYPTO_AHASH_REQ_VIRT ;
include/linux/crypto.h +0 -15
@@ -14,7 +14,6 @@#include <linux/completion.h> #include <linux/errno.h> -#include <linux/list.h> #include <linux/refcount.h> #include <linux/slab.h> #include <linux/types.h>
@@ -188,7 +187,6 @@ struct crypto_async_request {struct crypto_tfm *tfm;u32 flags; -int err; };/**
@@ -482,19 +480,6 @@ static inline unsigned int crypto_tfm_ctx_alignment(void) return __alignof__(tfm->__crt_ctx); } -static inline void crypto_reqchain_init (struct crypto_async_request *req) -{ - req->err = -EINPROGRESS ; -INIT_LIST_HEAD (&req->list); -} - -static inline void crypto_request_chain (struct crypto_async_request *req, -struct crypto_async_request *head) -{ - req->err = -EINPROGRESS ; -list_add_tail (&req->list, &head->list); -} -static inline bool crypto_tfm_is_async (struct crypto_tfm *tfm) {return tfm->__crt_alg->cra_flags &CRYPTO_ALG_ASYNC ;
Signature · 1 line
2.39.5