Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2025-01-07 21:53:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

crypto: virtio - Use new crypto_engine_op interface

Browse Source 
Use the new crypto_engine_op interface where the callback is stored
in the algorithm object.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Herbert Xu 2023-08-13 14:55:16 +08:00
parent d5e6b48f94
commit 7a2673d70c
2 changed files with 30 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
drivers/crypto/virtio/virtio_crypto_akcipher_algs.c
View File

@ -7,15 +7,16 @@
* Copyright 2022 Bytedance CO., LTD. * Copyright 2022 Bytedance CO., LTD.
*/ */
#include <linux/mpi.h> #include <crypto/engine.h>
#include <linux/scatterlist.h>
#include <crypto/algapi.h>
#include <crypto/internal/akcipher.h> #include <crypto/internal/akcipher.h>
#include <crypto/internal/rsa.h> #include <crypto/internal/rsa.h>
#include <linux/err.h>
#include <crypto/scatterwalk.h> #include <crypto/scatterwalk.h>
#include <linux/atomic.h> #include <linux/err.h>
#include <linux/kernel.h>
#include <linux/mpi.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <uapi/linux/virtio_crypto.h> #include <uapi/linux/virtio_crypto.h>
#include "virtio_crypto_common.h" #include "virtio_crypto_common.h"
@ -24,7 +25,6 @@ struct virtio_crypto_rsa_ctx {
}; };
struct virtio_crypto_akcipher_ctx { struct virtio_crypto_akcipher_ctx {
struct crypto_engine_ctx enginectx;
struct virtio_crypto *vcrypto; struct virtio_crypto *vcrypto;
struct crypto_akcipher *tfm; struct crypto_akcipher *tfm;
bool session_valid; bool session_valid;
@ -47,7 +47,7 @@ struct virtio_crypto_akcipher_algo {
uint32_t algonum; uint32_t algonum;
uint32_t service; uint32_t service;
unsigned int active_devs; unsigned int active_devs;
struct akcipher_alg algo; struct akcipher_engine_alg algo;
}; };
static DEFINE_MUTEX(algs_lock); static DEFINE_MUTEX(algs_lock);
@ -475,7 +475,6 @@ static int virtio_crypto_rsa_init_tfm(struct crypto_akcipher *tfm)
struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm); struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm);
ctx->tfm = tfm; ctx->tfm = tfm;
ctx->enginectx.op.do_one_request = virtio_crypto_rsa_do_req;
akcipher_set_reqsize(tfm, akcipher_set_reqsize(tfm,
sizeof(struct virtio_crypto_akcipher_request)); sizeof(struct virtio_crypto_akcipher_request));
@ -498,7 +497,7 @@ static struct virtio_crypto_akcipher_algo virtio_crypto_akcipher_algs[] = {
{ {
.algonum = VIRTIO_CRYPTO_AKCIPHER_RSA, .algonum = VIRTIO_CRYPTO_AKCIPHER_RSA,
.service = VIRTIO_CRYPTO_SERVICE_AKCIPHER, .service = VIRTIO_CRYPTO_SERVICE_AKCIPHER,
.algo = { .algo.base = {
.encrypt = virtio_crypto_rsa_encrypt, .encrypt = virtio_crypto_rsa_encrypt,
.decrypt = virtio_crypto_rsa_decrypt, .decrypt = virtio_crypto_rsa_decrypt,
.set_pub_key = virtio_crypto_rsa_raw_set_pub_key, .set_pub_key = virtio_crypto_rsa_raw_set_pub_key,
@ -514,11 +513,14 @@ static struct virtio_crypto_akcipher_algo virtio_crypto_akcipher_algs[] = {
.cra_ctxsize = sizeof(struct virtio_crypto_akcipher_ctx), .cra_ctxsize = sizeof(struct virtio_crypto_akcipher_ctx),
}, },
}, },
.algo.op = {
.do_one_request = virtio_crypto_rsa_do_req,
},
}, },
{ {
.algonum = VIRTIO_CRYPTO_AKCIPHER_RSA, .algonum = VIRTIO_CRYPTO_AKCIPHER_RSA,
.service = VIRTIO_CRYPTO_SERVICE_AKCIPHER, .service = VIRTIO_CRYPTO_SERVICE_AKCIPHER,
.algo = { .algo.base = {
.encrypt = virtio_crypto_rsa_encrypt, .encrypt = virtio_crypto_rsa_encrypt,
.decrypt = virtio_crypto_rsa_decrypt, .decrypt = virtio_crypto_rsa_decrypt,
.sign = virtio_crypto_rsa_sign, .sign = virtio_crypto_rsa_sign,
@ -536,6 +538,9 @@ static struct virtio_crypto_akcipher_algo virtio_crypto_akcipher_algs[] = {
.cra_ctxsize = sizeof(struct virtio_crypto_akcipher_ctx), .cra_ctxsize = sizeof(struct virtio_crypto_akcipher_ctx),
}, },
}, },
.algo.op = {
.do_one_request = virtio_crypto_rsa_do_req,
},
}, },
}; };
@ -554,14 +559,14 @@ int virtio_crypto_akcipher_algs_register(struct virtio_crypto *vcrypto)
continue; continue;
if (virtio_crypto_akcipher_algs[i].active_devs == 0) { if (virtio_crypto_akcipher_algs[i].active_devs == 0) {
ret = crypto_register_akcipher(&virtio_crypto_akcipher_algs[i].algo); ret = crypto_engine_register_akcipher(&virtio_crypto_akcipher_algs[i].algo);
if (ret) if (ret)
goto unlock; goto unlock;
} }
virtio_crypto_akcipher_algs[i].active_devs++; virtio_crypto_akcipher_algs[i].active_devs++;
dev_info(&vcrypto->vdev->dev, "Registered akcipher algo %s\n", dev_info(&vcrypto->vdev->dev, "Registered akcipher algo %s\n",
virtio_crypto_akcipher_algs[i].algo.base.cra_name); virtio_crypto_akcipher_algs[i].algo.base.base.cra_name);
} }
unlock: unlock:
@ -584,7 +589,7 @@ void virtio_crypto_akcipher_algs_unregister(struct virtio_crypto *vcrypto)
continue; continue;
if (virtio_crypto_akcipher_algs[i].active_devs == 1) if (virtio_crypto_akcipher_algs[i].active_devs == 1)
crypto_unregister_akcipher(&virtio_crypto_akcipher_algs[i].algo); crypto_engine_unregister_akcipher(&virtio_crypto_akcipher_algs[i].algo);
virtio_crypto_akcipher_algs[i].active_devs--; virtio_crypto_akcipher_algs[i].active_devs--;
} }

23
drivers/crypto/virtio/virtio_crypto_skcipher_algs.c
View File

@ -6,19 +6,16 @@
* Copyright 2016 HUAWEI TECHNOLOGIES CO., LTD. * Copyright 2016 HUAWEI TECHNOLOGIES CO., LTD.
*/ */
#include <linux/scatterlist.h> #include <crypto/engine.h>
#include <crypto/algapi.h>
#include <crypto/internal/skcipher.h> #include <crypto/internal/skcipher.h>
#include <linux/err.h>
#include <crypto/scatterwalk.h> #include <crypto/scatterwalk.h>
#include <linux/atomic.h> #include <linux/err.h>
#include <linux/scatterlist.h>
#include <uapi/linux/virtio_crypto.h> #include <uapi/linux/virtio_crypto.h>
#include "virtio_crypto_common.h" #include "virtio_crypto_common.h"
struct virtio_crypto_skcipher_ctx { struct virtio_crypto_skcipher_ctx {
struct crypto_engine_ctx enginectx;
struct virtio_crypto *vcrypto; struct virtio_crypto *vcrypto;
struct crypto_skcipher *tfm; struct crypto_skcipher *tfm;
@ -42,7 +39,7 @@ struct virtio_crypto_algo {
uint32_t algonum; uint32_t algonum;
uint32_t service; uint32_t service;
unsigned int active_devs; unsigned int active_devs;
struct skcipher_alg algo; struct skcipher_engine_alg algo;
}; };
/* /*
@ -523,7 +520,6 @@ static int virtio_crypto_skcipher_init(struct crypto_skcipher *tfm)
crypto_skcipher_set_reqsize(tfm, sizeof(struct virtio_crypto_sym_request)); crypto_skcipher_set_reqsize(tfm, sizeof(struct virtio_crypto_sym_request));
ctx->tfm = tfm; ctx->tfm = tfm;
ctx->enginectx.op.do_one_request = virtio_crypto_skcipher_crypt_req;
return 0; return 0;
} }
@ -578,7 +574,7 @@ static void virtio_crypto_skcipher_finalize_req(
static struct virtio_crypto_algo virtio_crypto_algs[] = { { static struct virtio_crypto_algo virtio_crypto_algs[] = { {
.algonum = VIRTIO_CRYPTO_CIPHER_AES_CBC, .algonum = VIRTIO_CRYPTO_CIPHER_AES_CBC,
.service = VIRTIO_CRYPTO_SERVICE_CIPHER, .service = VIRTIO_CRYPTO_SERVICE_CIPHER,
.algo = { .algo.base = {
.base.cra_name = "cbc(aes)", .base.cra_name = "cbc(aes)",
.base.cra_driver_name = "virtio_crypto_aes_cbc", .base.cra_driver_name = "virtio_crypto_aes_cbc",
.base.cra_priority = 150, .base.cra_priority = 150,
@ -596,6 +592,9 @@ static struct virtio_crypto_algo virtio_crypto_algs[] = { {
.max_keysize = AES_MAX_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE, .ivsize = AES_BLOCK_SIZE,
}, },
.algo.op = {
.do_one_request = virtio_crypto_skcipher_crypt_req,
},
} }; } };
int virtio_crypto_skcipher_algs_register(struct virtio_crypto *vcrypto) int virtio_crypto_skcipher_algs_register(struct virtio_crypto *vcrypto)
@ -614,14 +613,14 @@ int virtio_crypto_skcipher_algs_register(struct virtio_crypto *vcrypto)
continue; continue;
if (virtio_crypto_algs[i].active_devs == 0) { if (virtio_crypto_algs[i].active_devs == 0) {
ret = crypto_register_skcipher(&virtio_crypto_algs[i].algo); ret = crypto_engine_register_skcipher(&virtio_crypto_algs[i].algo);
if (ret) if (ret)
goto unlock; goto unlock;
} }
virtio_crypto_algs[i].active_devs++; virtio_crypto_algs[i].active_devs++;
dev_info(&vcrypto->vdev->dev, "Registered algo %s\n", dev_info(&vcrypto->vdev->dev, "Registered algo %s\n",
virtio_crypto_algs[i].algo.base.cra_name); virtio_crypto_algs[i].algo.base.base.cra_name);
} }
unlock: unlock:
@ -645,7 +644,7 @@ void virtio_crypto_skcipher_algs_unregister(struct virtio_crypto *vcrypto)
continue; continue;
if (virtio_crypto_algs[i].active_devs == 1) if (virtio_crypto_algs[i].active_devs == 1)
crypto_unregister_skcipher(&virtio_crypto_algs[i].algo); crypto_engine_unregister_skcipher(&virtio_crypto_algs[i].algo);
virtio_crypto_algs[i].active_devs--; virtio_crypto_algs[i].active_devs--;
} }