mirror of
https://github.com/torvalds/linux.git
synced 2026-07-27 17:47:41 +02:00
Merge branch 'remove-unused-support-for-crypto-tfm-cloning'
Eric Biggers says: ==================== Remove unused support for crypto tfm cloning This series is targeting net-next because it depends on "net/tcp: Remove tcp_sigpool". So far no commits in cryptodev conflict with this, so I suggest that this be taken through net-next for 7.2. This series removes support for transformation cloning from the crypto API. Now that the TCP-AO and TCP-MD5 code no longer uses it, it no longer has a user. And it's unlikely that a new one will appear, as the library API solves the problem in a much simpler and more efficient way. This feature also regressed performance for all crypto API users, since it changed crypto transformation objects into reference-counted objects. That added expensive atomic operations. The refcount is reverted by this series, thus fixing the performance regression. A subset of this was previously sent in https://lore.kernel.org/r/20260307224341.5644-1-ebiggers@kernel.org Compared to that version, this version is a bit more comprehensive. ==================== Link: https://patch.msgid.link/20260522053028.91165-1-ebiggers@kernel.org Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Jakub Kicinski
commit
f945ec1a7d
|
|
@ -862,76 +862,6 @@ bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_hash_alg_has_setkey);
|
||||
|
||||
struct crypto_ahash *crypto_clone_ahash(struct crypto_ahash *hash)
|
||||
{
|
||||
struct hash_alg_common *halg = crypto_hash_alg_common(hash);
|
||||
struct crypto_tfm *tfm = crypto_ahash_tfm(hash);
|
||||
struct crypto_ahash *fb = NULL;
|
||||
struct crypto_ahash *nhash;
|
||||
struct ahash_alg *alg;
|
||||
int err;
|
||||
|
||||
if (!crypto_hash_alg_has_setkey(halg)) {
|
||||
tfm = crypto_tfm_get(tfm);
|
||||
if (IS_ERR(tfm))
|
||||
return ERR_CAST(tfm);
|
||||
|
||||
return hash;
|
||||
}
|
||||
|
||||
nhash = crypto_clone_tfm(&crypto_ahash_type, tfm);
|
||||
|
||||
if (IS_ERR(nhash))
|
||||
return nhash;
|
||||
|
||||
nhash->reqsize = hash->reqsize;
|
||||
nhash->statesize = hash->statesize;
|
||||
|
||||
if (likely(hash->using_shash)) {
|
||||
struct crypto_shash **nctx = crypto_ahash_ctx(nhash);
|
||||
struct crypto_shash *shash;
|
||||
|
||||
shash = crypto_clone_shash(ahash_to_shash(hash));
|
||||
if (IS_ERR(shash)) {
|
||||
err = PTR_ERR(shash);
|
||||
goto out_free_nhash;
|
||||
}
|
||||
crypto_ahash_tfm(nhash)->exit = crypto_exit_ahash_using_shash;
|
||||
nhash->using_shash = true;
|
||||
*nctx = shash;
|
||||
return nhash;
|
||||
}
|
||||
|
||||
if (crypto_ahash_need_fallback(hash)) {
|
||||
fb = crypto_clone_ahash(crypto_ahash_fb(hash));
|
||||
err = PTR_ERR(fb);
|
||||
if (IS_ERR(fb))
|
||||
goto out_free_nhash;
|
||||
|
||||
crypto_ahash_tfm(nhash)->fb = crypto_ahash_tfm(fb);
|
||||
}
|
||||
|
||||
err = -ENOSYS;
|
||||
alg = crypto_ahash_alg(hash);
|
||||
if (!alg->clone_tfm)
|
||||
goto out_free_fb;
|
||||
|
||||
err = alg->clone_tfm(nhash, hash);
|
||||
if (err)
|
||||
goto out_free_fb;
|
||||
|
||||
crypto_ahash_tfm(nhash)->exit = crypto_ahash_exit_tfm;
|
||||
|
||||
return nhash;
|
||||
|
||||
out_free_fb:
|
||||
crypto_free_ahash(fb);
|
||||
out_free_nhash:
|
||||
crypto_free_ahash(nhash);
|
||||
return ERR_PTR(err);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_clone_ahash);
|
||||
|
||||
static int ahash_default_export_core(struct ahash_request *req, void *out)
|
||||
{
|
||||
return -ENOSYS;
|
||||
|
|
|
|||
76
crypto/api.c
76
crypto/api.c
|
|
@ -405,20 +405,19 @@ void crypto_shoot_alg(struct crypto_alg *alg)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_shoot_alg);
|
||||
|
||||
struct crypto_tfm *__crypto_alloc_tfmgfp(struct crypto_alg *alg, u32 type,
|
||||
u32 mask, gfp_t gfp)
|
||||
struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
|
||||
u32 mask)
|
||||
{
|
||||
struct crypto_tfm *tfm;
|
||||
unsigned int tfm_size;
|
||||
int err = -ENOMEM;
|
||||
|
||||
tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask);
|
||||
tfm = kzalloc(tfm_size, gfp);
|
||||
tfm = kzalloc(tfm_size, GFP_KERNEL);
|
||||
if (tfm == NULL)
|
||||
goto out_err;
|
||||
|
||||
tfm->__crt_alg = alg;
|
||||
refcount_set(&tfm->refcnt, 1);
|
||||
|
||||
if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
|
||||
goto cra_init_failed;
|
||||
|
|
@ -435,13 +434,6 @@ struct crypto_tfm *__crypto_alloc_tfmgfp(struct crypto_alg *alg, u32 type,
|
|||
out:
|
||||
return tfm;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(__crypto_alloc_tfmgfp);
|
||||
|
||||
struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
|
||||
u32 mask)
|
||||
{
|
||||
return __crypto_alloc_tfmgfp(alg, type, mask, GFP_KERNEL);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(__crypto_alloc_tfm);
|
||||
|
||||
/*
|
||||
|
|
@ -500,43 +492,23 @@ struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_alloc_base);
|
||||
|
||||
static void *crypto_alloc_tfmmem(struct crypto_alg *alg,
|
||||
const struct crypto_type *frontend, int node,
|
||||
gfp_t gfp)
|
||||
{
|
||||
struct crypto_tfm *tfm;
|
||||
unsigned int tfmsize;
|
||||
unsigned int total;
|
||||
char *mem;
|
||||
|
||||
tfmsize = frontend->tfmsize;
|
||||
total = tfmsize + sizeof(*tfm) + frontend->extsize(alg);
|
||||
|
||||
mem = kzalloc_node(total, gfp, node);
|
||||
if (mem == NULL)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
tfm = (struct crypto_tfm *)(mem + tfmsize);
|
||||
tfm->__crt_alg = alg;
|
||||
tfm->node = node;
|
||||
refcount_set(&tfm->refcnt, 1);
|
||||
|
||||
return mem;
|
||||
}
|
||||
|
||||
void *crypto_create_tfm_node(struct crypto_alg *alg,
|
||||
const struct crypto_type *frontend,
|
||||
int node)
|
||||
{
|
||||
struct crypto_tfm *tfm;
|
||||
size_t size;
|
||||
char *mem;
|
||||
int err;
|
||||
|
||||
mem = crypto_alloc_tfmmem(alg, frontend, node, GFP_KERNEL);
|
||||
if (IS_ERR(mem))
|
||||
goto out;
|
||||
size = frontend->tfmsize + sizeof(*tfm) + frontend->extsize(alg);
|
||||
mem = kzalloc_node(size, GFP_KERNEL, node);
|
||||
if (!mem)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
tfm = (struct crypto_tfm *)(mem + frontend->tfmsize);
|
||||
tfm->__crt_alg = alg;
|
||||
tfm->node = node;
|
||||
tfm->fb = tfm;
|
||||
|
||||
err = frontend->init_tfm(tfm);
|
||||
|
|
@ -560,32 +532,6 @@ void *crypto_create_tfm_node(struct crypto_alg *alg,
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_create_tfm_node);
|
||||
|
||||
void *crypto_clone_tfm(const struct crypto_type *frontend,
|
||||
struct crypto_tfm *otfm)
|
||||
{
|
||||
struct crypto_alg *alg = otfm->__crt_alg;
|
||||
struct crypto_tfm *tfm;
|
||||
char *mem;
|
||||
|
||||
mem = ERR_PTR(-ESTALE);
|
||||
if (unlikely(!crypto_mod_get(alg)))
|
||||
goto out;
|
||||
|
||||
mem = crypto_alloc_tfmmem(alg, frontend, otfm->node, GFP_ATOMIC);
|
||||
if (IS_ERR(mem)) {
|
||||
crypto_mod_put(alg);
|
||||
goto out;
|
||||
}
|
||||
|
||||
tfm = (struct crypto_tfm *)(mem + frontend->tfmsize);
|
||||
tfm->crt_flags = otfm->crt_flags;
|
||||
tfm->fb = tfm;
|
||||
|
||||
out:
|
||||
return mem;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_clone_tfm);
|
||||
|
||||
struct crypto_alg *crypto_find_alg(const char *alg_name,
|
||||
const struct crypto_type *frontend,
|
||||
u32 type, u32 mask)
|
||||
|
|
@ -675,8 +621,6 @@ void crypto_destroy_tfm(void *mem, struct crypto_tfm *tfm)
|
|||
if (IS_ERR_OR_NULL(mem))
|
||||
return;
|
||||
|
||||
if (!refcount_dec_and_test(&tfm->refcnt))
|
||||
return;
|
||||
alg = tfm->__crt_alg;
|
||||
|
||||
if (!tfm->exit && alg->cra_exit)
|
||||
|
|
|
|||
|
|
@ -89,31 +89,3 @@ void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
|
|||
cipher_crypt_one(tfm, dst, src, false);
|
||||
}
|
||||
EXPORT_SYMBOL_NS_GPL(crypto_cipher_decrypt_one, "CRYPTO_INTERNAL");
|
||||
|
||||
struct crypto_cipher *crypto_clone_cipher(struct crypto_cipher *cipher)
|
||||
{
|
||||
struct crypto_tfm *tfm = crypto_cipher_tfm(cipher);
|
||||
struct crypto_alg *alg = tfm->__crt_alg;
|
||||
struct crypto_cipher *ncipher;
|
||||
struct crypto_tfm *ntfm;
|
||||
|
||||
if (alg->cra_init)
|
||||
return ERR_PTR(-ENOSYS);
|
||||
|
||||
if (unlikely(!crypto_mod_get(alg)))
|
||||
return ERR_PTR(-ESTALE);
|
||||
|
||||
ntfm = __crypto_alloc_tfmgfp(alg, CRYPTO_ALG_TYPE_CIPHER,
|
||||
CRYPTO_ALG_TYPE_MASK, GFP_ATOMIC);
|
||||
if (IS_ERR(ntfm)) {
|
||||
crypto_mod_put(alg);
|
||||
return ERR_CAST(ntfm);
|
||||
}
|
||||
|
||||
ntfm->crt_flags = tfm->crt_flags;
|
||||
|
||||
ncipher = __crypto_cipher_cast(ntfm);
|
||||
|
||||
return ncipher;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_clone_cipher);
|
||||
|
|
|
|||
|
|
@ -151,21 +151,6 @@ static int cmac_init_tfm(struct crypto_shash *tfm)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int cmac_clone_tfm(struct crypto_shash *tfm, struct crypto_shash *otfm)
|
||||
{
|
||||
struct cmac_tfm_ctx *octx = crypto_shash_ctx(otfm);
|
||||
struct cmac_tfm_ctx *ctx = crypto_shash_ctx(tfm);
|
||||
struct crypto_cipher *cipher;
|
||||
|
||||
cipher = crypto_clone_cipher(octx->child);
|
||||
if (IS_ERR(cipher))
|
||||
return PTR_ERR(cipher);
|
||||
|
||||
ctx->child = cipher;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cmac_exit_tfm(struct crypto_shash *tfm)
|
||||
{
|
||||
struct cmac_tfm_ctx *ctx = crypto_shash_ctx(tfm);
|
||||
|
|
@ -222,7 +207,6 @@ static int cmac_create(struct crypto_template *tmpl, struct rtattr **tb)
|
|||
inst->alg.finup = crypto_cmac_digest_finup;
|
||||
inst->alg.setkey = crypto_cmac_digest_setkey;
|
||||
inst->alg.init_tfm = cmac_init_tfm;
|
||||
inst->alg.clone_tfm = cmac_clone_tfm;
|
||||
inst->alg.exit_tfm = cmac_exit_tfm;
|
||||
|
||||
inst->free = shash_free_singlespawn_instance;
|
||||
|
|
|
|||
|
|
@ -452,21 +452,6 @@ static int cryptd_hash_init_tfm(struct crypto_ahash *tfm)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int cryptd_hash_clone_tfm(struct crypto_ahash *ntfm,
|
||||
struct crypto_ahash *tfm)
|
||||
{
|
||||
struct cryptd_hash_ctx *nctx = crypto_ahash_ctx(ntfm);
|
||||
struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(tfm);
|
||||
struct crypto_shash *hash;
|
||||
|
||||
hash = crypto_clone_shash(ctx->child);
|
||||
if (IS_ERR(hash))
|
||||
return PTR_ERR(hash);
|
||||
|
||||
nctx->child = hash;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cryptd_hash_exit_tfm(struct crypto_ahash *tfm)
|
||||
{
|
||||
struct cryptd_hash_ctx *ctx = crypto_ahash_ctx(tfm);
|
||||
|
|
@ -700,7 +685,6 @@ static int cryptd_create_hash(struct crypto_template *tmpl, struct rtattr **tb,
|
|||
inst->alg.halg.base.cra_ctxsize = sizeof(struct cryptd_hash_ctx);
|
||||
|
||||
inst->alg.init_tfm = cryptd_hash_init_tfm;
|
||||
inst->alg.clone_tfm = cryptd_hash_clone_tfm;
|
||||
inst->alg.exit_tfm = cryptd_hash_exit_tfm;
|
||||
|
||||
inst->alg.init = cryptd_hash_init_enqueue;
|
||||
|
|
|
|||
|
|
@ -158,20 +158,6 @@ static int hmac_init_tfm(struct crypto_shash *parent)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int hmac_clone_tfm(struct crypto_shash *dst, struct crypto_shash *src)
|
||||
{
|
||||
struct hmac_ctx *sctx = crypto_shash_ctx(src);
|
||||
struct hmac_ctx *dctx = crypto_shash_ctx(dst);
|
||||
struct crypto_shash *hash;
|
||||
|
||||
hash = crypto_clone_shash(sctx->hash);
|
||||
if (IS_ERR(hash))
|
||||
return PTR_ERR(hash);
|
||||
|
||||
dctx->hash = hash;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void hmac_exit_tfm(struct crypto_shash *parent)
|
||||
{
|
||||
struct hmac_ctx *tctx = crypto_shash_ctx(parent);
|
||||
|
|
@ -235,7 +221,6 @@ static int __hmac_create_shash(struct crypto_template *tmpl,
|
|||
inst->alg.import_core = hmac_import_core;
|
||||
inst->alg.setkey = hmac_setkey;
|
||||
inst->alg.init_tfm = hmac_init_tfm;
|
||||
inst->alg.clone_tfm = hmac_clone_tfm;
|
||||
inst->alg.exit_tfm = hmac_exit_tfm;
|
||||
|
||||
inst->free = shash_free_singlespawn_instance;
|
||||
|
|
@ -423,21 +408,6 @@ static int hmac_init_ahash_tfm(struct crypto_ahash *parent)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int hmac_clone_ahash_tfm(struct crypto_ahash *dst,
|
||||
struct crypto_ahash *src)
|
||||
{
|
||||
struct ahash_hmac_ctx *sctx = crypto_ahash_ctx(src);
|
||||
struct ahash_hmac_ctx *dctx = crypto_ahash_ctx(dst);
|
||||
struct crypto_ahash *hash;
|
||||
|
||||
hash = crypto_clone_ahash(sctx->hash);
|
||||
if (IS_ERR(hash))
|
||||
return PTR_ERR(hash);
|
||||
|
||||
dctx->hash = hash;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void hmac_exit_ahash_tfm(struct crypto_ahash *parent)
|
||||
{
|
||||
struct ahash_hmac_ctx *tctx = crypto_ahash_ctx(parent);
|
||||
|
|
@ -503,7 +473,6 @@ static int hmac_create_ahash(struct crypto_template *tmpl, struct rtattr **tb,
|
|||
inst->alg.import_core = hmac_import_core_ahash;
|
||||
inst->alg.setkey = hmac_setkey_ahash;
|
||||
inst->alg.init_tfm = hmac_init_ahash_tfm;
|
||||
inst->alg.clone_tfm = hmac_clone_ahash_tfm;
|
||||
inst->alg.exit_tfm = hmac_exit_ahash_tfm;
|
||||
|
||||
inst->free = ahash_free_singlespawn_instance;
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@
|
|||
|
||||
#include <crypto/algapi.h>
|
||||
#include <linux/completion.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/jump_label.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/module.h>
|
||||
|
|
@ -120,14 +119,10 @@ void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
|
|||
struct crypto_alg *nalg);
|
||||
void crypto_remove_final(struct list_head *list);
|
||||
void crypto_shoot_alg(struct crypto_alg *alg);
|
||||
struct crypto_tfm *__crypto_alloc_tfmgfp(struct crypto_alg *alg, u32 type,
|
||||
u32 mask, gfp_t gfp);
|
||||
struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
|
||||
u32 mask);
|
||||
void *crypto_create_tfm_node(struct crypto_alg *alg,
|
||||
const struct crypto_type *frontend, int node);
|
||||
void *crypto_clone_tfm(const struct crypto_type *frontend,
|
||||
struct crypto_tfm *otfm);
|
||||
|
||||
static inline void *crypto_create_tfm(struct crypto_alg *alg,
|
||||
const struct crypto_type *frontend)
|
||||
|
|
@ -211,10 +206,5 @@ static inline int crypto_is_test_larval(struct crypto_larval *larval)
|
|||
return larval->alg.cra_driver_name[0];
|
||||
}
|
||||
|
||||
static inline struct crypto_tfm *crypto_tfm_get(struct crypto_tfm *tfm)
|
||||
{
|
||||
return refcount_inc_not_zero(&tfm->refcnt) ? tfm : ERR_PTR(-EOVERFLOW);
|
||||
}
|
||||
|
||||
#endif /* _CRYPTO_INTERNAL_H */
|
||||
|
||||
|
|
|
|||
|
|
@ -395,43 +395,6 @@ int crypto_has_shash(const char *alg_name, u32 type, u32 mask)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_has_shash);
|
||||
|
||||
struct crypto_shash *crypto_clone_shash(struct crypto_shash *hash)
|
||||
{
|
||||
struct crypto_tfm *tfm = crypto_shash_tfm(hash);
|
||||
struct shash_alg *alg = crypto_shash_alg(hash);
|
||||
struct crypto_shash *nhash;
|
||||
int err;
|
||||
|
||||
if (!crypto_shash_alg_has_setkey(alg)) {
|
||||
tfm = crypto_tfm_get(tfm);
|
||||
if (IS_ERR(tfm))
|
||||
return ERR_CAST(tfm);
|
||||
|
||||
return hash;
|
||||
}
|
||||
|
||||
if (!alg->clone_tfm && (alg->init_tfm || alg->base.cra_init))
|
||||
return ERR_PTR(-ENOSYS);
|
||||
|
||||
nhash = crypto_clone_tfm(&crypto_shash_type, tfm);
|
||||
if (IS_ERR(nhash))
|
||||
return nhash;
|
||||
|
||||
if (alg->clone_tfm) {
|
||||
err = alg->clone_tfm(nhash, hash);
|
||||
if (err) {
|
||||
crypto_free_shash(nhash);
|
||||
return ERR_PTR(err);
|
||||
}
|
||||
}
|
||||
|
||||
if (alg->exit_tfm)
|
||||
crypto_shash_tfm(nhash)->exit = crypto_shash_exit_tfm;
|
||||
|
||||
return nhash;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_clone_shash);
|
||||
|
||||
int hash_prepare_alg(struct hash_alg_common *alg)
|
||||
{
|
||||
struct crypto_alg *base = &alg->base;
|
||||
|
|
|
|||
|
|
@ -148,7 +148,6 @@ struct ahash_request {
|
|||
* @exit_tfm: Deinitialize the cryptographic transformation object.
|
||||
* This is a counterpart to @init_tfm, used to remove
|
||||
* various changes set in @init_tfm.
|
||||
* @clone_tfm: Copy transform into new object, may allocate memory.
|
||||
* @halg: see struct hash_alg_common
|
||||
*/
|
||||
struct ahash_alg {
|
||||
|
|
@ -165,7 +164,6 @@ struct ahash_alg {
|
|||
unsigned int keylen);
|
||||
int (*init_tfm)(struct crypto_ahash *tfm);
|
||||
void (*exit_tfm)(struct crypto_ahash *tfm);
|
||||
int (*clone_tfm)(struct crypto_ahash *dst, struct crypto_ahash *src);
|
||||
|
||||
struct hash_alg_common halg;
|
||||
};
|
||||
|
|
@ -239,7 +237,6 @@ struct shash_desc {
|
|||
* @exit_tfm: Deinitialize the cryptographic transformation object.
|
||||
* This is a counterpart to @init_tfm, used to remove
|
||||
* various changes set in @init_tfm.
|
||||
* @clone_tfm: Copy transform into new object, may allocate memory.
|
||||
* @descsize: Size of the operational state for the message digest. This state
|
||||
* size is the memory size that needs to be allocated for
|
||||
* shash_desc.__ctx
|
||||
|
|
@ -263,7 +260,6 @@ struct shash_alg {
|
|||
unsigned int keylen);
|
||||
int (*init_tfm)(struct crypto_shash *tfm);
|
||||
void (*exit_tfm)(struct crypto_shash *tfm);
|
||||
int (*clone_tfm)(struct crypto_shash *dst, struct crypto_shash *src);
|
||||
|
||||
unsigned int descsize;
|
||||
|
||||
|
|
@ -322,8 +318,6 @@ static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
|
|||
struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
|
||||
u32 mask);
|
||||
|
||||
struct crypto_ahash *crypto_clone_ahash(struct crypto_ahash *tfm);
|
||||
|
||||
static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
|
||||
{
|
||||
return &tfm->base;
|
||||
|
|
@ -759,8 +753,6 @@ static inline void ahash_request_set_virt(struct ahash_request *req,
|
|||
struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
|
||||
u32 mask);
|
||||
|
||||
struct crypto_shash *crypto_clone_shash(struct crypto_shash *tfm);
|
||||
|
||||
int crypto_has_shash(const char *alg_name, u32 type, u32 mask);
|
||||
|
||||
static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
|
||||
|
|
|
|||
|
|
@ -176,8 +176,6 @@ void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
|
|||
void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
|
||||
u8 *dst, const u8 *src);
|
||||
|
||||
struct crypto_cipher *crypto_clone_cipher(struct crypto_cipher *cipher);
|
||||
|
||||
struct crypto_cipher_spawn {
|
||||
struct crypto_spawn base;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -409,7 +409,6 @@ int crypto_has_alg(const char *name, u32 type, u32 mask);
|
|||
*/
|
||||
|
||||
struct crypto_tfm {
|
||||
refcount_t refcnt;
|
||||
|
||||
u32 crt_flags;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user