Skip to content

L
linux
Commit d3eff572 authored by Gilad Ben-Yossef's avatar Gilad Ben-Yossef Committed by Greg Kroah-Hartman
Browse files
Options

staging: ccree: remove last remnants of sash algo 

The hash code had some left overs from a misguided attempt
to support shash API with the HW. Remove the code handling
this.
Signed-off-by: default avatarGilad Ben-Yossef <gilad@benyossef.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 087fabd1
Show whitespace changes
Inline Side-by-side
Showing with 127 additions and 321 deletions
drivers/staging/ccree/ssi_hash.c
View file @ d3eff572
...@@ -76,15 +76,11 @@ static void ssi_hash_create_cmac_setup(struct ahash_request *areq, ...@@ -76,15 +76,11 @@ static void ssi_hash_create_cmac_setup(struct ahash_request *areq,
struct ssi_hash_alg { struct ssi_hash_alg {
struct list_head entry; struct list_head entry;
bool synchronize;
int hash_mode; int hash_mode;
int hw_mode; int hw_mode;
int inter_digestsize; int inter_digestsize;
struct ssi_drvdata *drvdata; struct ssi_drvdata *drvdata;
union {
struct ahash_alg ahash_alg; struct ahash_alg ahash_alg;
struct shash_alg shash_alg;
};
}; };
...@@ -112,8 +108,6 @@ struct ssi_hash_ctx { ...@@ -112,8 +108,6 @@ struct ssi_hash_ctx {
bool is_hmac; bool is_hmac;
}; };
static const struct crypto_type crypto_shash_type;
static void ssi_hash_create_data_desc( static void ssi_hash_create_data_desc(
struct ahash_req_ctx *areq_ctx, struct ahash_req_ctx *areq_ctx,
struct ssi_hash_ctx *ctx, struct ssi_hash_ctx *ctx,
...@@ -1015,15 +1009,9 @@ static int ssi_hash_setkey(void *hash, ...@@ -1015,15 +1009,9 @@ static int ssi_hash_setkey(void *hash,
SSI_LOG_DEBUG("ssi_hash_setkey: start keylen: %d", keylen); SSI_LOG_DEBUG("ssi_hash_setkey: start keylen: %d", keylen);
CHECK_AND_RETURN_UPON_FIPS_ERROR(); CHECK_AND_RETURN_UPON_FIPS_ERROR();
if (synchronize) {
ctx = crypto_shash_ctx(((struct crypto_shash *)hash));
blocksize = crypto_tfm_alg_blocksize(&((struct crypto_shash *)hash)->base);
digestsize = crypto_shash_digestsize(((struct crypto_shash *)hash));
} else {
ctx = crypto_ahash_ctx(((struct crypto_ahash *)hash)); ctx = crypto_ahash_ctx(((struct crypto_ahash *)hash));
blocksize = crypto_tfm_alg_blocksize(&((struct crypto_ahash *)hash)->base); blocksize = crypto_tfm_alg_blocksize(&((struct crypto_ahash *)hash)->base);
digestsize = crypto_ahash_digestsize(((struct crypto_ahash *)hash)); digestsize = crypto_ahash_digestsize(((struct crypto_ahash *)hash));
}
larval_addr = ssi_ahash_get_larval_digest_sram_addr( larval_addr = ssi_ahash_get_larval_digest_sram_addr(
ctx->drvdata, ctx->hash_mode); ctx->drvdata, ctx->hash_mode);
...@@ -1184,13 +1172,8 @@ static int ssi_hash_setkey(void *hash, ...@@ -1184,13 +1172,8 @@ static int ssi_hash_setkey(void *hash,
rc = send_request(ctx->drvdata, &ssi_req, desc, idx, 0); rc = send_request(ctx->drvdata, &ssi_req, desc, idx, 0);
out: out:
if (rc != 0) { if (rc)
if (synchronize) {
crypto_shash_set_flags((struct crypto_shash *)hash, CRYPTO_TFM_RES_BAD_KEY_LEN);
} else {
crypto_ahash_set_flags((struct crypto_ahash *)hash, CRYPTO_TFM_RES_BAD_KEY_LEN); crypto_ahash_set_flags((struct crypto_ahash *)hash, CRYPTO_TFM_RES_BAD_KEY_LEN);
}
}
if (ctx->key_params.key_dma_addr) { if (ctx->key_params.key_dma_addr) {
dma_unmap_single(&ctx->drvdata->plat_dev->dev, dma_unmap_single(&ctx->drvdata->plat_dev->dev,
...@@ -1395,23 +1378,6 @@ static int ssi_hash_alloc_ctx(struct ssi_hash_ctx *ctx) ...@@ -1395,23 +1378,6 @@ static int ssi_hash_alloc_ctx(struct ssi_hash_ctx *ctx)
return -ENOMEM; return -ENOMEM;
} }
static int ssi_shash_cra_init(struct crypto_tfm *tfm)
{
struct ssi_hash_ctx *ctx = crypto_tfm_ctx(tfm);
struct shash_alg * shash_alg =
container_of(tfm->__crt_alg, struct shash_alg, base);
struct ssi_hash_alg *ssi_alg =
container_of(shash_alg, struct ssi_hash_alg, shash_alg);
CHECK_AND_RETURN_UPON_FIPS_ERROR();
ctx->hash_mode = ssi_alg->hash_mode;
ctx->hw_mode = ssi_alg->hw_mode;
ctx->inter_digestsize = ssi_alg->inter_digestsize;
ctx->drvdata = ssi_alg->drvdata;
return ssi_hash_alloc_ctx(ctx);
}
static int ssi_ahash_cra_init(struct crypto_tfm *tfm) static int ssi_ahash_cra_init(struct crypto_tfm *tfm)
{ {
struct ssi_hash_ctx *ctx = crypto_tfm_ctx(tfm); struct ssi_hash_ctx *ctx = crypto_tfm_ctx(tfm);
...@@ -1764,100 +1730,6 @@ static int ssi_mac_digest(struct ahash_request *req) ...@@ -1764,100 +1730,6 @@ static int ssi_mac_digest(struct ahash_request *req)
return rc; return rc;
} }
//shash wrap functions
#ifdef SYNC_ALGS
static int ssi_shash_digest(struct shash_desc *desc,
const u8 *data, unsigned int len, u8 *out)
{
struct ahash_req_ctx *state = shash_desc_ctx(desc);
struct crypto_shash *tfm = desc->tfm;
struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);
u32 digestsize = crypto_shash_digestsize(tfm);
struct scatterlist src;
if (len == 0) {
return ssi_hash_digest(state, ctx, digestsize, NULL, 0, out, NULL);
}
/* sg_init_one may crash when len is 0 (depends on kernel configuration) */
sg_init_one(&src, (const void *)data, len);
return ssi_hash_digest(state, ctx, digestsize, &src, len, out, NULL);
}
static int ssi_shash_update(struct shash_desc *desc,
const u8 *data, unsigned int len)
{
struct ahash_req_ctx *state = shash_desc_ctx(desc);
struct crypto_shash *tfm = desc->tfm;
struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);
u32 blocksize = crypto_tfm_alg_blocksize(&tfm->base);
struct scatterlist src;
sg_init_one(&src, (const void *)data, len);
return ssi_hash_update(state, ctx, blocksize, &src, len, NULL);
}
static int ssi_shash_finup(struct shash_desc *desc,
const u8 *data, unsigned int len, u8 *out)
{
struct ahash_req_ctx *state = shash_desc_ctx(desc);
struct crypto_shash *tfm = desc->tfm;
struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);
u32 digestsize = crypto_shash_digestsize(tfm);
struct scatterlist src;
sg_init_one(&src, (const void *)data, len);
return ssi_hash_finup(state, ctx, digestsize, &src, len, out, NULL);
}
static int ssi_shash_final(struct shash_desc *desc, u8 *out)
{
struct ahash_req_ctx *state = shash_desc_ctx(desc);
struct crypto_shash *tfm = desc->tfm;
struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);
u32 digestsize = crypto_shash_digestsize(tfm);
return ssi_hash_final(state, ctx, digestsize, NULL, 0, out, NULL);
}
static int ssi_shash_init(struct shash_desc *desc)
{
struct ahash_req_ctx *state = shash_desc_ctx(desc);
struct crypto_shash *tfm = desc->tfm;
struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);
return ssi_hash_init(state, ctx);
}
#ifdef EXPORT_FIXED
static int ssi_shash_export(struct shash_desc *desc, void *out)
{
struct crypto_shash *tfm = desc->tfm;
struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);
return ssi_hash_export(ctx, out);
}
static int ssi_shash_import(struct shash_desc *desc, const void *in)
{
struct crypto_shash *tfm = desc->tfm;
struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);
return ssi_hash_import(ctx, in);
}
#endif
static int ssi_shash_setkey(struct crypto_shash *tfm,
const u8 *key, unsigned int keylen)
{
return ssi_hash_setkey((void *) tfm, key, keylen, true);
}
#endif /* SYNC_ALGS */
//ahash wrap functions //ahash wrap functions
static int ssi_ahash_digest(struct ahash_request *req) static int ssi_ahash_digest(struct ahash_request *req)
{ {
...@@ -1941,10 +1813,7 @@ struct ssi_hash_template { ...@@ -1941,10 +1813,7 @@ struct ssi_hash_template {
char hmac_driver_name[CRYPTO_MAX_ALG_NAME]; char hmac_driver_name[CRYPTO_MAX_ALG_NAME];
unsigned int blocksize; unsigned int blocksize;
bool synchronize; bool synchronize;
union {
struct ahash_alg template_ahash; struct ahash_alg template_ahash;
struct shash_alg template_shash;
};
int hash_mode; int hash_mode;
int hw_mode; int hw_mode;
int inter_digestsize; int inter_digestsize;
...@@ -1961,7 +1830,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -1961,7 +1830,6 @@ static struct ssi_hash_template driver_hash[] = {
.hmac_driver_name = "hmac-sha1-dx", .hmac_driver_name = "hmac-sha1-dx",
.blocksize = SHA1_BLOCK_SIZE, .blocksize = SHA1_BLOCK_SIZE,
.synchronize = false, .synchronize = false,
{
.template_ahash = { .template_ahash = {
.init = ssi_ahash_init, .init = ssi_ahash_init,
.update = ssi_ahash_update, .update = ssi_ahash_update,
...@@ -1978,7 +1846,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -1978,7 +1846,6 @@ static struct ssi_hash_template driver_hash[] = {
.statesize = sizeof(struct sha1_state), .statesize = sizeof(struct sha1_state),
}, },
}, },
},
.hash_mode = DRV_HASH_SHA1, .hash_mode = DRV_HASH_SHA1,
.hw_mode = DRV_HASH_HW_SHA1, .hw_mode = DRV_HASH_HW_SHA1,
.inter_digestsize = SHA1_DIGEST_SIZE, .inter_digestsize = SHA1_DIGEST_SIZE,
...@@ -1989,8 +1856,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -1989,8 +1856,6 @@ static struct ssi_hash_template driver_hash[] = {
.hmac_name = "hmac(sha256)", .hmac_name = "hmac(sha256)",
.hmac_driver_name = "hmac-sha256-dx", .hmac_driver_name = "hmac-sha256-dx",
.blocksize = SHA256_BLOCK_SIZE, .blocksize = SHA256_BLOCK_SIZE,
.synchronize = false,
{
.template_ahash = { .template_ahash = {
.init = ssi_ahash_init, .init = ssi_ahash_init,
.update = ssi_ahash_update, .update = ssi_ahash_update,
...@@ -2007,7 +1872,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2007,7 +1872,6 @@ static struct ssi_hash_template driver_hash[] = {
.statesize = sizeof(struct sha256_state), .statesize = sizeof(struct sha256_state),
}, },
}, },
},
.hash_mode = DRV_HASH_SHA256, .hash_mode = DRV_HASH_SHA256,
.hw_mode = DRV_HASH_HW_SHA256, .hw_mode = DRV_HASH_HW_SHA256,
.inter_digestsize = SHA256_DIGEST_SIZE, .inter_digestsize = SHA256_DIGEST_SIZE,
...@@ -2018,8 +1882,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2018,8 +1882,6 @@ static struct ssi_hash_template driver_hash[] = {
.hmac_name = "hmac(sha224)", .hmac_name = "hmac(sha224)",
.hmac_driver_name = "hmac-sha224-dx", .hmac_driver_name = "hmac-sha224-dx",
.blocksize = SHA224_BLOCK_SIZE, .blocksize = SHA224_BLOCK_SIZE,
.synchronize = false,
{
.template_ahash = { .template_ahash = {
.init = ssi_ahash_init, .init = ssi_ahash_init,
.update = ssi_ahash_update, .update = ssi_ahash_update,
...@@ -2036,7 +1898,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2036,7 +1898,6 @@ static struct ssi_hash_template driver_hash[] = {
.statesize = sizeof(struct sha256_state), .statesize = sizeof(struct sha256_state),
}, },
}, },
},
.hash_mode = DRV_HASH_SHA224, .hash_mode = DRV_HASH_SHA224,
.hw_mode = DRV_HASH_HW_SHA256, .hw_mode = DRV_HASH_HW_SHA256,
.inter_digestsize = SHA256_DIGEST_SIZE, .inter_digestsize = SHA256_DIGEST_SIZE,
...@@ -2048,8 +1909,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2048,8 +1909,6 @@ static struct ssi_hash_template driver_hash[] = {
.hmac_name = "hmac(sha384)", .hmac_name = "hmac(sha384)",
.hmac_driver_name = "hmac-sha384-dx", .hmac_driver_name = "hmac-sha384-dx",
.blocksize = SHA384_BLOCK_SIZE, .blocksize = SHA384_BLOCK_SIZE,
.synchronize = false,
{
.template_ahash = { .template_ahash = {
.init = ssi_ahash_init, .init = ssi_ahash_init,
.update = ssi_ahash_update, .update = ssi_ahash_update,
...@@ -2066,7 +1925,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2066,7 +1925,6 @@ static struct ssi_hash_template driver_hash[] = {
.statesize = sizeof(struct sha512_state), .statesize = sizeof(struct sha512_state),
}, },
}, },
},
.hash_mode = DRV_HASH_SHA384, .hash_mode = DRV_HASH_SHA384,
.hw_mode = DRV_HASH_HW_SHA512, .hw_mode = DRV_HASH_HW_SHA512,
.inter_digestsize = SHA512_DIGEST_SIZE, .inter_digestsize = SHA512_DIGEST_SIZE,
...@@ -2077,8 +1935,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2077,8 +1935,6 @@ static struct ssi_hash_template driver_hash[] = {
.hmac_name = "hmac(sha512)", .hmac_name = "hmac(sha512)",
.hmac_driver_name = "hmac-sha512-dx", .hmac_driver_name = "hmac-sha512-dx",
.blocksize = SHA512_BLOCK_SIZE, .blocksize = SHA512_BLOCK_SIZE,
.synchronize = false,
{
.template_ahash = { .template_ahash = {
.init = ssi_ahash_init, .init = ssi_ahash_init,
.update = ssi_ahash_update, .update = ssi_ahash_update,
...@@ -2095,7 +1951,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2095,7 +1951,6 @@ static struct ssi_hash_template driver_hash[] = {
.statesize = sizeof(struct sha512_state), .statesize = sizeof(struct sha512_state),
}, },
}, },
},
.hash_mode = DRV_HASH_SHA512, .hash_mode = DRV_HASH_SHA512,
.hw_mode = DRV_HASH_HW_SHA512, .hw_mode = DRV_HASH_HW_SHA512,
.inter_digestsize = SHA512_DIGEST_SIZE, .inter_digestsize = SHA512_DIGEST_SIZE,
...@@ -2107,8 +1962,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2107,8 +1962,6 @@ static struct ssi_hash_template driver_hash[] = {
.hmac_name = "hmac(md5)", .hmac_name = "hmac(md5)",
.hmac_driver_name = "hmac-md5-dx", .hmac_driver_name = "hmac-md5-dx",
.blocksize = MD5_HMAC_BLOCK_SIZE, .blocksize = MD5_HMAC_BLOCK_SIZE,
.synchronize = false,
{
.template_ahash = { .template_ahash = {
.init = ssi_ahash_init, .init = ssi_ahash_init,
.update = ssi_ahash_update, .update = ssi_ahash_update,
...@@ -2125,7 +1978,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2125,7 +1978,6 @@ static struct ssi_hash_template driver_hash[] = {
.statesize = sizeof(struct md5_state), .statesize = sizeof(struct md5_state),
}, },
}, },
},
.hash_mode = DRV_HASH_MD5, .hash_mode = DRV_HASH_MD5,
.hw_mode = DRV_HASH_HW_MD5, .hw_mode = DRV_HASH_HW_MD5,
.inter_digestsize = MD5_DIGEST_SIZE, .inter_digestsize = MD5_DIGEST_SIZE,
...@@ -2134,8 +1986,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2134,8 +1986,6 @@ static struct ssi_hash_template driver_hash[] = {
.name = "xcbc(aes)", .name = "xcbc(aes)",
.driver_name = "xcbc-aes-dx", .driver_name = "xcbc-aes-dx",
.blocksize = AES_BLOCK_SIZE, .blocksize = AES_BLOCK_SIZE,
.synchronize = false,
{
.template_ahash = { .template_ahash = {
.init = ssi_ahash_init, .init = ssi_ahash_init,
.update = ssi_mac_update, .update = ssi_mac_update,
...@@ -2152,7 +2002,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2152,7 +2002,6 @@ static struct ssi_hash_template driver_hash[] = {
.statesize = sizeof(struct aeshash_state), .statesize = sizeof(struct aeshash_state),
}, },
}, },
},
.hash_mode = DRV_HASH_NULL, .hash_mode = DRV_HASH_NULL,
.hw_mode = DRV_CIPHER_XCBC_MAC, .hw_mode = DRV_CIPHER_XCBC_MAC,
.inter_digestsize = AES_BLOCK_SIZE, .inter_digestsize = AES_BLOCK_SIZE,
...@@ -2162,8 +2011,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2162,8 +2011,6 @@ static struct ssi_hash_template driver_hash[] = {
.name = "cmac(aes)", .name = "cmac(aes)",
.driver_name = "cmac-aes-dx", .driver_name = "cmac-aes-dx",
.blocksize = AES_BLOCK_SIZE, .blocksize = AES_BLOCK_SIZE,
.synchronize = false,
{
.template_ahash = { .template_ahash = {
.init = ssi_ahash_init, .init = ssi_ahash_init,
.update = ssi_mac_update, .update = ssi_mac_update,
...@@ -2180,7 +2027,6 @@ static struct ssi_hash_template driver_hash[] = { ...@@ -2180,7 +2027,6 @@ static struct ssi_hash_template driver_hash[] = {
.statesize = sizeof(struct aeshash_state), .statesize = sizeof(struct aeshash_state),
}, },
}, },
},
.hash_mode = DRV_HASH_NULL, .hash_mode = DRV_HASH_NULL,
.hw_mode = DRV_CIPHER_CMAC, .hw_mode = DRV_CIPHER_CMAC,
.inter_digestsize = AES_BLOCK_SIZE, .inter_digestsize = AES_BLOCK_SIZE,
...@@ -2194,6 +2040,7 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed) ...@@ -2194,6 +2040,7 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed)
{ {
struct ssi_hash_alg *t_crypto_alg; struct ssi_hash_alg *t_crypto_alg;
struct crypto_alg *alg; struct crypto_alg *alg;
struct ahash_alg *halg;
t_crypto_alg = kzalloc(sizeof(struct ssi_hash_alg), GFP_KERNEL); t_crypto_alg = kzalloc(sizeof(struct ssi_hash_alg), GFP_KERNEL);
if (!t_crypto_alg) { if (!t_crypto_alg) {
...@@ -2201,20 +2048,9 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed) ...@@ -2201,20 +2048,9 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }
t_crypto_alg->synchronize = template->synchronize;
if (template->synchronize) {
struct shash_alg *halg;
t_crypto_alg->shash_alg = template->template_shash;
halg = &t_crypto_alg->shash_alg;
alg = &halg->base;
if (!keyed) halg->setkey = NULL;
} else {
struct ahash_alg *halg;
t_crypto_alg->ahash_alg = template->template_ahash; t_crypto_alg->ahash_alg = template->template_ahash;
halg = &t_crypto_alg->ahash_alg; halg = &t_crypto_alg->ahash_alg;
alg = &halg->halg.base; alg = &halg->halg.base;
if (!keyed) halg->setkey = NULL;
}
if (keyed) { if (keyed) {
snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
...@@ -2222,6 +2058,7 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed) ...@@ -2222,6 +2058,7 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed)
snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
template->hmac_driver_name); template->hmac_driver_name);
} else { } else {
halg->setkey = NULL;
snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
template->name); template->name);
snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
...@@ -2234,17 +2071,10 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed) ...@@ -2234,17 +2071,10 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed)
alg->cra_alignmask = 0; alg->cra_alignmask = 0;
alg->cra_exit = ssi_hash_cra_exit; alg->cra_exit = ssi_hash_cra_exit;
if (template->synchronize) {
alg->cra_init = ssi_shash_cra_init;
alg->cra_flags = CRYPTO_ALG_TYPE_SHASH |
CRYPTO_ALG_KERN_DRIVER_ONLY;
alg->cra_type = &crypto_shash_type;
} else {
alg->cra_init = ssi_ahash_cra_init; alg->cra_init = ssi_ahash_cra_init;
alg->cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_TYPE_AHASH | alg->cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_TYPE_AHASH |
CRYPTO_ALG_KERN_DRIVER_ONLY; CRYPTO_ALG_KERN_DRIVER_ONLY;
alg->cra_type = &crypto_ahash_type; alg->cra_type = &crypto_ahash_type;
}
t_crypto_alg->hash_mode = template->hash_mode; t_crypto_alg->hash_mode = template->hash_mode;
t_crypto_alg->hw_mode = template->hw_mode; t_crypto_alg->hw_mode = template->hw_mode;
...@@ -2429,24 +2259,15 @@ int ssi_hash_alloc(struct ssi_drvdata *drvdata) ...@@ -2429,24 +2259,15 @@ int ssi_hash_alloc(struct ssi_drvdata *drvdata)
} }
t_alg->drvdata = drvdata; t_alg->drvdata = drvdata;
if (t_alg->synchronize) {
rc = crypto_register_shash(&t_alg->shash_alg);
if (unlikely(rc != 0)) {
SSI_LOG_ERR("%s alg registration failed\n",
t_alg->shash_alg.base.cra_driver_name);
kfree(t_alg);
goto fail;
} else
list_add_tail(&t_alg->entry, &hash_handle->hash_list);
} else {
rc = crypto_register_ahash(&t_alg->ahash_alg); rc = crypto_register_ahash(&t_alg->ahash_alg);
if (unlikely(rc != 0)) { if (unlikely(rc)) {
SSI_LOG_ERR("%s alg registration failed\n", SSI_LOG_ERR("%s alg registration failed\n",
t_alg->ahash_alg.halg.base.cra_driver_name); driver_hash[alg].driver_name);
kfree(t_alg); kfree(t_alg);
goto fail; goto fail;
} else } else {
list_add_tail(&t_alg->entry, &hash_handle->hash_list); list_add_tail(&t_alg->entry,
&hash_handle->hash_list);
} }
} }
...@@ -2460,24 +2281,13 @@ int ssi_hash_alloc(struct ssi_drvdata *drvdata) ...@@ -2460,24 +2281,13 @@ int ssi_hash_alloc(struct ssi_drvdata *drvdata)
} }
t_alg->drvdata = drvdata; t_alg->drvdata = drvdata;
if (t_alg->synchronize) {
rc = crypto_register_shash(&t_alg->shash_alg);
if (unlikely(rc != 0)) {
SSI_LOG_ERR("%s alg registration failed\n",
t_alg->shash_alg.base.cra_driver_name);
kfree(t_alg);
goto fail;
} else
list_add_tail(&t_alg->entry, &hash_handle->hash_list);
} else {
rc = crypto_register_ahash(&t_alg->ahash_alg); rc = crypto_register_ahash(&t_alg->ahash_alg);
if (unlikely(rc != 0)) { if (unlikely(rc)) {
SSI_LOG_ERR("%s alg registration failed\n", SSI_LOG_ERR("%s alg registration failed\n",
t_alg->ahash_alg.halg.base.cra_driver_name); driver_hash[alg].driver_name);
kfree(t_alg); kfree(t_alg);
goto fail; goto fail;
} else } else {
list_add_tail(&t_alg->entry, &hash_handle->hash_list); list_add_tail(&t_alg->entry, &hash_handle->hash_list);
} }
} }
...@@ -2501,11 +2311,7 @@ int ssi_hash_free(struct ssi_drvdata *drvdata) ...@@ -2501,11 +2311,7 @@ int ssi_hash_free(struct ssi_drvdata *drvdata)
if (hash_handle != NULL) { if (hash_handle != NULL) {
list_for_each_entry_safe(t_hash_alg, hash_n, &hash_handle->hash_list, entry) { list_for_each_entry_safe(t_hash_alg, hash_n, &hash_handle->hash_list, entry) {
if (t_hash_alg->synchronize) {
crypto_unregister_shash(&t_hash_alg->shash_alg);
} else {
crypto_unregister_ahash(&t_hash_alg->ahash_alg); crypto_unregister_ahash(&t_hash_alg->ahash_alg);
}
list_del(&t_hash_alg->entry); list_del(&t_hash_alg->entry);
kfree(t_hash_alg); kfree(t_hash_alg);
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7