crypto: acomp - Use optional async calling convention
Subsystems (4)
Herbert Xu
maintainercover crypto: acomp - Use optional async calling convention
This patch series introduces the optional async calling convention for acomp. This will be extended to all other Crypto API types that support async.
With this a stack request is setup initially and will be used as long as the algorithm can complete synchronously. If it cannot then EAGAIN is returned, and the caller may choose to allocate a dynamic request through the REQUEST_CLONE call and then redo the call asynchronously.
This series is based on top of
https://lore.kernel.org/linux-crypto/[email protected]
Herbert Xu (7):
crypto: api - Add helpers to manage request flags
crypto: acomp - Use request flag helpers and add acomp_request_flags
crypto: acomp - Add ACOMP_FBREQ_ON_STACK
crypto: iaa - Switch to ACOMP_FBREQ_ON_STACK
crypto: acomp - Add ACOMP_REQUEST_CLONE
ubifs: Use ACOMP_REQUEST_CLONE
crypto: acomp - Remove ACOMP_REQUEST_ALLOC
crypto/acompress.c | 37 +-- drivers/crypto/intel/iaa/iaa_crypto_main.c | 5 +- fs/ubifs/compress.c | 251 ++++++++++----------- include/crypto/acompress.h | 48 ++-- include/crypto/algapi.h | 5 + include/crypto/internal/acompress.h | 33 ++- include/linux/crypto.h | 24 ++ 7 files changed, 227 insertions(+), 176 deletions(-)
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH 1/7 crypto: api - Add helpers to manage request flags
Add helpers so that the ON_STACK request flag management is not duplicated all over the place.
--- include/crypto/algapi.h | 5 +++++ include/linux/crypto.h | 24 ++++++++++++++++++++++++ 2 files changed, 29 insertions(+)
include/crypto/algapi.h +5 -0
@@ -272,4 +272,9 @@ static inline bool crypto_tfm_req_chain(struct crypto_tfm *tfm) return tfm->__crt_alg->cra_flags & CRYPTO_ALG_REQ_CHAIN; } +static inline u32 crypto_request_flags (struct crypto_async_request *req) +{ +return req->flags & ~CRYPTO_TFM_REQ_ON_STACK ; +} +#endif /* _CRYPTO_ALGAPI_H */
include/linux/crypto.h +24 -0
@@ -476,5 +476,29 @@ static inline bool crypto_tfm_is_async(struct crypto_tfm *tfm) return tfm->__crt_alg->cra_flags & CRYPTO_ALG_ASYNC; } +static inline bool crypto_req_on_stack (struct crypto_async_request *req) +{ +return req->flags &CRYPTO_TFM_REQ_ON_STACK ; +} + +static inline void crypto_request_set_callback ( +struct crypto_async_request *req,u32 flags, +crypto_completion_t compl,void *data) +{ +u32 keep =CRYPTO_TFM_REQ_ON_STACK ; + + req->complete = compl; + req->data = data; + req->flags &= keep; + req->flags |= flags & ~keep; +} + +static inline void crypto_request_set_tfm (struct crypto_async_request *req, +struct crypto_tfm *tfm) +{ + req->tfm = tfm; + req->flags &= ~CRYPTO_TFM_REQ_ON_STACK ; +} +#endif /* _LINUX_CRYPTO_H */
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH 2/7 crypto: acomp - Use request flag helpers and add acomp_request_flags
In reply to Herbert XuUse the newly added request flag helpers to manage the request flags.
Also add acomp_request_flags which lets bottom-level users to access the request flags without the bits private to the acomp API.
--- include/crypto/acompress.h | 27 ++++++++++++++++----------- include/crypto/internal/acompress.h | 6 ++++++ 2 files changed, 22 insertions(+), 11 deletions(-)
include/crypto/acompress.h +16 -11
@@ -38,6 +38,12 @@/* Set this bit if destination is a folio. */ #define CRYPTO_ACOMP_REQ_DST_FOLIO 0x00000040 +/* Private flags that should not be touched by the user. */ +#define CRYPTO_ACOMP_REQ_PRIVATE \ + (CRYPTO_ACOMP_REQ_SRC_VIRT | CRYPTO_ACOMP_REQ_SRC_NONDMA | \ + CRYPTO_ACOMP_REQ_DST_VIRT | CRYPTO_ACOMP_REQ_DST_NONDMA | \ + CRYPTO_ACOMP_REQ_SRC_FOLIO | CRYPTO_ACOMP_REQ_DST_FOLIO) +#define CRYPTO_ACOMP_DST_MAX 131072#define MAX_SYNC_COMP_REQSIZE 0
@@ -201,7 +207,7 @@ static inline unsigned int crypto_acomp_reqsize(struct crypto_acomp *tfm)static inline void acomp_request_set_tfm (struct acomp_req *req,struct crypto_acomp *tfm) { - req->base.tfm =crypto_acomp_tfm (tfm); +crypto_request_set_tfm (&req->base,crypto_acomp_tfm (tfm)); }static inline bool acomp_is_async (struct crypto_acomp *tfm)
@@ -298,6 +304,11 @@ static inline void *acomp_request_extra(struct acomp_req *req)return (void *)((char *)req + len); } +static inline bool acomp_req_on_stack (struct acomp_req *req) +{ +return crypto_req_on_stack (&req->base); +} +/** * acomp_request_free() -- zeroize and free asynchronous (de)compression * request as well as the output buffer if allocated
@@ -307,7 +318,7 @@ static inline void *acomp_request_extra(struct acomp_req *req)*/ static inline void acomp_request_free (struct acomp_req *req) { -if (!req || (req->base.flags &CRYPTO_TFM_REQ_ON_STACK )) +if (!req ||acomp_req_on_stack (req))return ;kfree_sensitive (req); }
@@ -328,15 +339,9 @@ static inline void acomp_request_set_callback(struct acomp_req *req,crypto_completion_t cmpl, void *data) { - u32 keep = CRYPTO_ACOMP_REQ_SRC_VIRT | CRYPTO_ACOMP_REQ_SRC_NONDMA | -CRYPTO_ACOMP_REQ_DST_VIRT |CRYPTO_ACOMP_REQ_DST_NONDMA | -CRYPTO_ACOMP_REQ_SRC_FOLIO |CRYPTO_ACOMP_REQ_DST_FOLIO | -CRYPTO_TFM_REQ_ON_STACK ; - - req->base.complete = cmpl; - req->base.data = data; - req->base.flags &= keep; - req->base.flags |= flgs & ~keep; + flgs &= ~CRYPTO_ACOMP_REQ_PRIVATE; + flgs |= req->base.flags &CRYPTO_ACOMP_REQ_PRIVATE ; +crypto_request_set_callback (&req->base, flgs, cmpl, data); }/**
include/crypto/internal/acompress.h +6 -0
@@ -229,4 +229,10 @@ static inline bool acomp_walk_more_src(const struct acomp_walk *walk, int cur) {return walk->slen != cur; } + +static inline u32 acomp_request_flags (struct acomp_req *req) +{ +return crypto_request_flags (&req->base) & ~CRYPTO_ACOMP_REQ_PRIVATE ; +} +#endif
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH 3/7 crypto: acomp - Add ACOMP_FBREQ_ON_STACK
In reply to Herbert XuAdd a helper to create an on-stack fallback request from a given request. Use this helper in acomp_do_nondma.
--- crypto/acompress.c | 14 +------------- include/crypto/internal/acompress.h | 26 ++++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 13 deletions(-)
crypto/acompress.c +1 -13
@@ -253,21 +253,9 @@ static void acomp_virt_to_sg(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 | -CRYPTO_ACOMP_REQ_DST_VIRT | -CRYPTO_ACOMP_REQ_DST_NONDMA ; -ACOMP_REQUEST_ON_STACK (fbreq,crypto_acomp_reqtfm (req)); +ACOMP_FBREQ_ON_STACK (fbreq, req);int err; -acomp_request_set_callback (fbreq, req->base.flags,NULL ,NULL ); - fbreq->base.flags &= ~keep; - fbreq->base.flags |= req->base.flags & keep; - fbreq->src = req->src; - fbreq->dst = req->dst; - fbreq->slen = req->slen; - fbreq->dlen = req->dlen; -if (comp) err =crypto_acomp_compress (fbreq);else
include/crypto/internal/acompress.h +26 -0
@@ -23,6 +23,12 @@struct acomp_req *name =acomp_request_on_stack_init ( \ __##name##_req, (tfm), 0, true) +#define ACOMP_FBREQ_ON_STACK (name, req) \ + char __##name##_req[sizeof(struct acomp_req) + \ + MAX_SYNC_COMP_REQSIZE] CRYPTO_MINALIGN_ATTR; \ + struct acomp_req *name = acomp_fbreq_on_stack_init( \ + __##name##_req, (req)) +/** * struct acomp_alg - asynchronous compression algorithm *
@@ -235,4 +241,24 @@ static inline u32 acomp_request_flags(struct acomp_req *req)return crypto_request_flags (&req->base) & ~CRYPTO_ACOMP_REQ_PRIVATE ; } +static inline struct acomp_req *acomp_fbreq_on_stack_init ( +char *buf,struct acomp_req *old) +{ +struct crypto_acomp *tfm =crypto_acomp_reqtfm (old); +struct acomp_req *req; + + req =acomp_request_on_stack_init (buf, tfm,0 , true); +acomp_request_set_callback (req,acomp_request_flags (old),NULL ,NULL ); + req->base.flags &= ~CRYPTO_ACOMP_REQ_PRIVATE ; + req->base.flags |= old->base.flags &CRYPTO_ACOMP_REQ_PRIVATE ; + req->src = old->src; + req->dst = old->dst; + req->slen = old->slen; + req->dlen = old->dlen; + req->soff = old->soff; + req->doff = old->doff; + +return req; +} +#endif
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH 4/7 crypto: iaa - Switch to ACOMP_FBREQ_ON_STACK
In reply to Herbert XuRather than copying the request by hand, use the ACOMP_FBREQ_ON_STACK helper to do it.
--- drivers/crypto/intel/iaa/iaa_crypto_main.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
drivers/crypto/intel/iaa/iaa_crypto_main.c +1 -4
@@ -999,12 +999,9 @@ static inline int check_completion(struct device *dev,static int deflate_generic_decompress (struct acomp_req *req) { -ACOMP_REQUEST_ON_STACK (fbreq,crypto_acomp_reqtfm (req)); +ACOMP_FBREQ_ON_STACK (fbreq, req);int ret; -acomp_request_set_callback (fbreq,0 ,NULL ,NULL ); -acomp_request_set_params (fbreq, req->src, req->dst, req->slen, - req->dlen); ret =crypto_acomp_decompress (fbreq); req->dlen = fbreq->dlen;
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH 5/7 crypto: acomp - Add ACOMP_REQUEST_CLONE
In reply to Herbert XuAdd a new helper ACOMP_REQUEST_CLONE that will transform a stack request into a dynamically allocated one if possible, and otherwise switch it over to the sycnrhonous fallback transform. The intended usage is:
ACOMP_STACK_ON_REQUEST(req, tfm);
...
err = crypto_acomp_compress(req);
/* The request cannot complete synchronously. */
if (err == -EAGAIN) {
/* This will not fail. */
req = ACOMP_REQUEST_CLONE(req, gfp);
/* Redo operation. */
err = crypto_acomp_compress(req);
}--- crypto/acompress.c | 23 ++++++++++++++++++++++ include/crypto/acompress.h | 30 +++++++++++++++++++++++++---- include/crypto/internal/acompress.h | 11 +++-------- 3 files changed, 52 insertions(+), 12 deletions(-)
crypto/acompress.c +23 -0
@@ -316,6 +316,8 @@ int crypto_acomp_compress(struct acomp_req *req) {struct crypto_acomp *tfm =crypto_acomp_reqtfm (req); +if (acomp_req_on_stack (req) &&acomp_is_async (tfm)) +return -EAGAIN ;if (crypto_acomp_req_chain (tfm) ||acomp_request_issg (req))crypto_acomp_reqtfm (req)->compress (req);return acomp_do_req_chain (req, true);
@@ -326,6 +328,8 @@ int crypto_acomp_decompress(struct acomp_req *req) {struct crypto_acomp *tfm =crypto_acomp_reqtfm (req); +if (acomp_req_on_stack (req) &&acomp_is_async (tfm)) +return -EAGAIN ;if (crypto_acomp_req_chain (tfm) ||acomp_request_issg (req))crypto_acomp_reqtfm (req)->decompress (req);return acomp_do_req_chain (req, false);
@@ -599,5 +603,24 @@ int acomp_walk_virt(struct acomp_walk *__restrict walk, }EXPORT_SYMBOL_GPL (acomp_walk_virt); +struct acomp_req *acomp_request_clone (struct acomp_req *req, +size_t total,gfp_t gfp) +{ +struct crypto_acomp *tfm =crypto_acomp_reqtfm (req); +struct acomp_req *nreq; + + nreq =kmalloc (total, gfp); +if (!nreq) { +acomp_request_set_tfm (req, tfm->fb); + req->base.flags =CRYPTO_TFM_REQ_ON_STACK ; +return req; + } + +memcpy (nreq, req, total); +acomp_request_set_tfm (req, tfm); +return req; +} +EXPORT_SYMBOL_GPL (acomp_request_clone); +MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Asynchronous compression type" );
include/crypto/acompress.h +26 -4
@@ -49,10 +49,19 @@#define MAX_SYNC_COMP_REQSIZE 0#define ACOMP_REQUEST_ALLOC (name, tfm, gfp) \ + char __##name##_req[sizeof(struct acomp_req) + \ + MAX_SYNC_COMP_REQSIZE] CRYPTO_MINALIGN_ATTR; \ + struct acomp_req *name = acomp_request_alloc_init( \ + __##name##_req, (tfm), (gfp)) + +#define ACOMP_REQUEST_ON_STACK (name, tfm) \ char __##name##_req[sizeof(struct acomp_req) + \ MAX_SYNC_COMP_REQSIZE] CRYPTO_MINALIGN_ATTR; \ struct acomp_req *name = acomp_request_on_stack_init( \ - __##name##_req, (tfm), (gfp), false) + __##name##_req, (tfm)) + +#define ACOMP_REQUEST_CLONE (name, gfp) \ + acomp_request_clone(name, sizeof(__##name##_req), gfp)struct acomp_req ;struct folio ;
@@ -571,12 +580,12 @@ int crypto_acomp_compress(struct acomp_req *req);*/ int crypto_acomp_decompress (struct acomp_req *req); -static inline struct acomp_req *acomp_request_on_stack_init ( -char *buf,struct crypto_acomp *tfm,gfp_t gfp,bool stackonly) +static inline struct acomp_req *acomp_request_alloc_init ( +char *buf,struct crypto_acomp *tfm,gfp_t gfp) {struct acomp_req *req; -if (!stackonly && (req =acomp_request_alloc (tfm, gfp))) +if ((req =acomp_request_alloc (tfm, gfp)))return req; req = (void *)buf;
@@ -586,4 +595,17 @@ static inline struct acomp_req *acomp_request_on_stack_init( return req; } +static inline struct acomp_req *acomp_request_on_stack_init ( +char *buf,struct crypto_acomp *tfm) +{ +struct acomp_req *req = (void *)buf; + +acomp_request_set_tfm (req, tfm); + req->base.flags =CRYPTO_TFM_REQ_ON_STACK ; +return req; +} + +struct acomp_req *acomp_request_clone (struct acomp_req *req, +size_t total,gfp_t gfp); +#endif
include/crypto/internal/acompress.h +3 -8
@@ -17,12 +17,6 @@#include <linux/spinlock.h> #include <linux/workqueue_types.h> -#define ACOMP_REQUEST_ON_STACK (name, tfm) \ - char __##name##_req[sizeof(struct acomp_req) + \ - MAX_SYNC_COMP_REQSIZE] CRYPTO_MINALIGN_ATTR; \ - struct acomp_req *name = acomp_request_on_stack_init( \ - __##name##_req, (tfm), 0, true) -#define ACOMP_FBREQ_ON_STACK (name, req) \ char __##name##_req[sizeof(struct acomp_req) + \ MAX_SYNC_COMP_REQSIZE] CRYPTO_MINALIGN_ATTR; \
@@ -245,9 +239,10 @@ static inline struct acomp_req *acomp_fbreq_on_stack_init( char *buf, struct acomp_req *old) { struct crypto_acomp *tfm = crypto_acomp_reqtfm(old); -struct acomp_req *req; +struct acomp_req *req = (void *)buf; - req =acomp_request_on_stack_init (buf, tfm,0 , true); +acomp_request_set_tfm (req, tfm->fb); + req->base.flags =CRYPTO_TFM_REQ_ON_STACK ;acomp_request_set_callback (req,acomp_request_flags (old),NULL ,NULL ); req->base.flags &= ~CRYPTO_ACOMP_REQ_PRIVATE ; req->base.flags |= old->base.flags &CRYPTO_ACOMP_REQ_PRIVATE ;
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH 6/7 ubifs: Use ACOMP_REQUEST_CLONE
In reply to Herbert XuSwitch to the new acomp API where stacks requests are used by default and a dynamic request is only allocted when necessary.
--- fs/ubifs/compress.c | 251 ++++++++++++++++++++------------------------ 1 file changed, 116 insertions(+), 135 deletions(-)
fs/ubifs/compress.c +116 -135
@@ -19,6 +19,11 @@#include <linux/highmem.h> #include "ubifs.h" +union ubifs_in_ptr { +const void *buf; +struct folio *folio; +}; +/* Fake description object for the "none" compressor */ static struct ubifs_compressor none_compr = { .compr_type =UBIFS_COMPR_NONE ,
@@ -68,28 +73,61 @@ static struct ubifs_compressor zstd_compr = {/* All UBIFS compressors */ struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT ]; -static int ubifs_compress_req (const struct ubifs_info *c, -struct acomp_req *req, -void *out_buf,int *out_len, -const char *compr_name) +static void ubifs_compress_common (int *compr_type,union ubifs_in_ptr in_ptr, +size_t in_offset,int in_len,bool in_folio, +void *out_buf,int *out_len) { -struct crypto_wait wait; -int in_len = req->slen; +struct ubifs_compressor *compr = ubifs_compressors[*compr_type];int dlen = *out_len;int err; +if (*compr_type ==UBIFS_COMPR_NONE ) + goto no_compr; + +/* If the input data is small, do not even try to compress it */ +if (in_len <UBIFS_MIN_COMPR_LEN ) + goto no_compr; + dlen =min (dlen, in_len -UBIFS_MIN_COMPRESS_DIFF ); -crypto_init_wait (&wait); -acomp_request_set_callback (req,CRYPTO_TFM_REQ_MAY_BACKLOG , - crypto_req_done, &wait); -acomp_request_set_dst_dma (req, out_buf, dlen); - err =crypto_acomp_compress (req); - err =crypto_wait_req (err, &wait); - *out_len = req->dlen; -acomp_request_free (req); +do { +ACOMP_REQUEST_ON_STACK (req, compr->cc); +DECLARE_CRYPTO_WAIT (wait); -return err; +acomp_request_set_callback (req,0 ,NULL ,NULL ); +if (in_folio) +acomp_request_set_src_folio (req, in_ptr.folio, + in_offset, in_len); +else +acomp_request_set_src_dma (req, in_ptr.buf, in_len); +acomp_request_set_dst_dma (req, out_buf, dlen); + err =crypto_acomp_compress (req); + dlen = req->dlen; +if (err != -EAGAIN ) +break ; + + req =ACOMP_REQUEST_CLONE (req,GFP_NOFS | __GFP_NOWARN); +acomp_request_set_callback (req,CRYPTO_TFM_REQ_MAY_BACKLOG , + crypto_req_done, &wait); + err =crypto_acomp_compress (req); + err =crypto_wait_req (err, &wait); + dlen = req->dlen; +acomp_request_free (req); + }while (0 ); + + *out_len = dlen; +if (err) + goto no_compr; + +return ; + +no_compr: +if (in_folio) +memcpy_from_folio (out_buf, in_ptr.folio, in_offset, in_len); +else +memcpy (out_buf, in_ptr.buf, in_len); + *out_len = in_len; + *compr_type =UBIFS_COMPR_NONE ; }/**
@@ -114,32 +152,10 @@ static int ubifs_compress_req(const struct ubifs_info *c,void ubifs_compress (const struct ubifs_info *c,const void *in_buf,int in_len,void *out_buf,int *out_len,int *compr_type) { -int err; -struct ubifs_compressor *compr = ubifs_compressors[*compr_type]; +union ubifs_in_ptr in_ptr = { .buf = in_buf }; -if (*compr_type ==UBIFS_COMPR_NONE ) - goto no_compr; - -/* If the input data is small, do not even try to compress it */ -if (in_len <UBIFS_MIN_COMPR_LEN ) - goto no_compr; - - { -ACOMP_REQUEST_ALLOC (req, compr->cc,GFP_NOFS | __GFP_NOWARN); - -acomp_request_set_src_dma (req, in_buf, in_len); - err =ubifs_compress_req (c, req, out_buf, out_len, compr->name); - } - -if (err) - goto no_compr; - -return ; - -no_compr: -memcpy (out_buf, in_buf, in_len); - *out_len = in_len; - *compr_type =UBIFS_COMPR_NONE ; +ubifs_compress_common (compr_type, in_ptr,0 , in_len, false, + out_buf, out_len); }/**
@@ -166,55 +182,71 @@ void ubifs_compress_folio(const struct ubifs_info *c, struct folio *in_folio, size_t in_offset, int in_len, void *out_buf, int *out_len, int *compr_type) { - int err; -struct ubifs_compressor *compr = ubifs_compressors[*compr_type]; + union ubifs_in_ptr in_ptr = { .folio = in_folio }; -if (*compr_type ==UBIFS_COMPR_NONE ) - goto no_compr; - -/* If the input data is small, do not even try to compress it */ -if (in_len <UBIFS_MIN_COMPR_LEN ) - goto no_compr; - - { -ACOMP_REQUEST_ALLOC (req, compr->cc,GFP_NOFS | __GFP_NOWARN); - -acomp_request_set_src_folio (req, in_folio, in_offset, in_len); - err =ubifs_compress_req (c, req, out_buf, out_len, compr->name); - } - -if (err) - goto no_compr; - -return ; - -no_compr: -memcpy_from_folio (out_buf, in_folio, in_offset, in_len); - *out_len = in_len; - *compr_type =UBIFS_COMPR_NONE ; +ubifs_compress_common (compr_type, in_ptr, in_offset, in_len, true, + out_buf, out_len); } -static int ubifs_decompress_req (const struct ubifs_info *c, -struct acomp_req *req, -const void *in_buf,int in_len,int *out_len, -const char *compr_name) +static int ubifs_decompress_common (const struct ubifs_info *c, +const void *in_buf,int in_len, +void *out_ptr,size_t out_offset, +int *out_len,bool out_folio, +int compr_type) { -struct crypto_wait wait; +struct ubifs_compressor *compr; +int dlen = *out_len;int err; -crypto_init_wait (&wait); -acomp_request_set_callback (req,CRYPTO_TFM_REQ_MAY_BACKLOG , - crypto_req_done, &wait); -acomp_request_set_src_dma (req, in_buf, in_len); - err =crypto_acomp_decompress (req); - err =crypto_wait_req (err, &wait); - *out_len = req->dlen; +if (unlikely (compr_type <0 || compr_type >=UBIFS_COMPR_TYPES_CNT )) { +ubifs_err (c,"invalid compression type %d" , compr_type); +return -EINVAL ; + } + compr = ubifs_compressors[compr_type]; + +if (unlikely (!compr->capi_name)) { +ubifs_err (c,"%s compression is not compiled in" , compr->name); +return -EINVAL ; + } + +if (compr_type ==UBIFS_COMPR_NONE ) { +if (out_folio) +memcpy_to_folio (out_ptr, out_offset, in_buf, in_len); +else +memcpy (out_ptr, in_buf, in_len); + *out_len = in_len; +return 0 ; + } + +do { +ACOMP_REQUEST_ON_STACK (req, compr->cc); +DECLARE_CRYPTO_WAIT (wait); + +acomp_request_set_callback (req,CRYPTO_TFM_REQ_MAY_BACKLOG , + crypto_req_done, &wait); +acomp_request_set_src_dma (req, in_buf, in_len); +if (out_folio) +acomp_request_set_dst_folio (req, out_ptr, out_offset, + dlen); +else +acomp_request_set_dst_dma (req, out_ptr, dlen); + err =crypto_acomp_decompress (req); + dlen = req->dlen; +if (err != -EAGAIN ) +break ; + + req =ACOMP_REQUEST_CLONE (req,GFP_NOFS | __GFP_NOWARN); + err =crypto_acomp_decompress (req); + err =crypto_wait_req (err, &wait); + dlen = req->dlen; +acomp_request_free (req); + }while (0 ); + + *out_len = dlen;if (err)ubifs_err (c,"cannot decompress %d bytes, compressor %s, error %d" , - in_len, compr_name, err); - -acomp_request_free (req); + in_len, compr->name, err);return err; }
@@ -235,33 +267,8 @@ static int ubifs_decompress_req(const struct ubifs_info *c,int ubifs_decompress (const struct ubifs_info *c,const void *in_buf,int in_len,void *out_buf,int *out_len,int compr_type) { -struct ubifs_compressor *compr; - -if (unlikely (compr_type <0 || compr_type >=UBIFS_COMPR_TYPES_CNT )) { -ubifs_err (c,"invalid compression type %d" , compr_type); -return -EINVAL ; - } - - compr = ubifs_compressors[compr_type]; - -if (unlikely (!compr->capi_name)) { -ubifs_err (c,"%s compression is not compiled in" , compr->name); -return -EINVAL ; - } - -if (compr_type ==UBIFS_COMPR_NONE ) { -memcpy (out_buf, in_buf, in_len); - *out_len = in_len; -return 0 ; - } - - { -ACOMP_REQUEST_ALLOC (req, compr->cc,GFP_NOFS | __GFP_NOWARN); - -acomp_request_set_dst_dma (req, out_buf, *out_len); -return ubifs_decompress_req (c, req, in_buf, in_len, out_len, - compr->name); - } +return ubifs_decompress_common (c, in_buf, in_len, out_buf,0 , out_len, + false, compr_type); }/**
@@ -283,34 +290,8 @@ int ubifs_decompress_folio(const struct ubifs_info *c, const void *in_buf, int in_len, struct folio *out_folio, size_t out_offset, int *out_len, int compr_type) { - struct ubifs_compressor *compr; - -if (unlikely (compr_type <0 || compr_type >=UBIFS_COMPR_TYPES_CNT )) { -ubifs_err (c,"invalid compression type %d" , compr_type); -return -EINVAL ; - } - - compr = ubifs_compressors[compr_type]; - -if (unlikely (!compr->capi_name)) { -ubifs_err (c,"%s compression is not compiled in" , compr->name); -return -EINVAL ; - } - -if (compr_type ==UBIFS_COMPR_NONE ) { -memcpy_to_folio (out_folio, out_offset, in_buf, in_len); - *out_len = in_len; -return 0 ; - } - - { -ACOMP_REQUEST_ALLOC (req, compr->cc,GFP_NOFS | __GFP_NOWARN); - -acomp_request_set_dst_folio (req, out_folio, out_offset, - *out_len); -return ubifs_decompress_req (c, req, in_buf, in_len, out_len, - compr->name); - } + return ubifs_decompress_common(c, in_buf, in_len, out_folio, +out_offset ,out_len ,true ,compr_type ); }/**
Signature · 1 line
2.39.5
Herbert Xu
maintainerPATCH 7/7 crypto: acomp - Remove ACOMP_REQUEST_ALLOC
In reply to Herbert XuRemove ACOMP_REQUEST_ALLOC in favour of ACOMP_REQUEST_ON_STACK with ACOMP_REQUEST_CLONE.
--- include/crypto/acompress.h | 21 --------------------- 1 file changed, 21 deletions(-)
include/crypto/acompress.h +0 -21
@@ -48,12 +48,6 @@#define MAX_SYNC_COMP_REQSIZE 0 -#define ACOMP_REQUEST_ALLOC (name, tfm, gfp) \ - char __##name##_req[sizeof(struct acomp_req) + \ - MAX_SYNC_COMP_REQSIZE] CRYPTO_MINALIGN_ATTR; \ - struct acomp_req *name = acomp_request_alloc_init( \ - __##name##_req, (tfm), (gfp)) -#define ACOMP_REQUEST_ON_STACK (name, tfm) \ char __##name##_req[sizeof(struct acomp_req) + \ MAX_SYNC_COMP_REQSIZE] CRYPTO_MINALIGN_ATTR; \
@@ -580,21 +574,6 @@ int crypto_acomp_compress(struct acomp_req *req);*/ int crypto_acomp_decompress (struct acomp_req *req); -static inline struct acomp_req *acomp_request_alloc_init ( -char *buf,struct crypto_acomp *tfm,gfp_t gfp) -{ -struct acomp_req *req; - -if ((req =acomp_request_alloc (tfm, gfp))) -return req; - - req = (void *)buf; -acomp_request_set_tfm (req, tfm->fb); - req->base.flags =CRYPTO_TFM_REQ_ON_STACK ; - -return req; -} -static inline struct acomp_req *acomp_request_on_stack_init (char *buf,struct crypto_acomp *tfm) {
Signature · 1 line
2.39.5