1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Asymmetric algorithms supported by virtio crypto device 3 * 4 * Authors: zhenwei pi <pizhenwei@bytedance.com> 5 * lei he <helei.sig11@bytedance.com> 6 * 7 * Copyright 2022 Bytedance CO., LTD. 8 */ 9 10 #include <crypto/engine.h> 11 #include <crypto/internal/akcipher.h> 12 #include <crypto/internal/rsa.h> 13 #include <crypto/scatterwalk.h> 14 #include <linux/err.h> 15 #include <linux/kernel.h> 16 #include <linux/mpi.h> 17 #include <linux/scatterlist.h> 18 #include <linux/slab.h> 19 #include <linux/string.h> 20 #include <uapi/linux/virtio_crypto.h> 21 #include "virtio_crypto_common.h" 22 23 struct virtio_crypto_rsa_ctx { 24 MPI n; 25 }; 26 27 struct virtio_crypto_akcipher_ctx { 28 struct virtio_crypto *vcrypto; 29 struct crypto_akcipher *tfm; 30 bool session_valid; 31 __u64 session_id; 32 union { 33 struct virtio_crypto_rsa_ctx rsa_ctx; 34 }; 35 }; 36 37 struct virtio_crypto_akcipher_request { 38 struct virtio_crypto_request base; 39 struct virtio_crypto_akcipher_ctx *akcipher_ctx; 40 struct akcipher_request *akcipher_req; 41 void *src_buf; 42 void *dst_buf; 43 uint32_t opcode; 44 }; 45 46 struct virtio_crypto_akcipher_algo { 47 uint32_t algonum; 48 uint32_t service; 49 unsigned int active_devs; 50 struct akcipher_engine_alg algo; 51 }; 52 53 static DEFINE_MUTEX(algs_lock); 54 55 static void virtio_crypto_akcipher_finalize_req( 56 struct virtio_crypto_akcipher_request *vc_akcipher_req, 57 struct akcipher_request *req, int err) 58 { 59 kfree(vc_akcipher_req->src_buf); 60 kfree(vc_akcipher_req->dst_buf); 61 vc_akcipher_req->src_buf = NULL; 62 vc_akcipher_req->dst_buf = NULL; 63 virtcrypto_clear_request(&vc_akcipher_req->base); 64 65 crypto_finalize_akcipher_request(vc_akcipher_req->base.dataq->engine, req, err); 66 } 67 68 static void virtio_crypto_dataq_akcipher_callback(struct virtio_crypto_request *vc_req, int len) 69 { 70 struct virtio_crypto_akcipher_request *vc_akcipher_req = 71 container_of(vc_req, struct virtio_crypto_akcipher_request, base); 72 struct akcipher_request *akcipher_req; 73 int error; 74 75 switch (vc_req->status) { 76 case VIRTIO_CRYPTO_OK: 77 error = 0; 78 break; 79 case VIRTIO_CRYPTO_INVSESS: 80 case VIRTIO_CRYPTO_ERR: 81 error = -EINVAL; 82 break; 83 case VIRTIO_CRYPTO_BADMSG: 84 error = -EBADMSG; 85 break; 86 87 case VIRTIO_CRYPTO_KEY_REJECTED: 88 error = -EKEYREJECTED; 89 break; 90 91 default: 92 error = -EIO; 93 break; 94 } 95 96 akcipher_req = vc_akcipher_req->akcipher_req; 97 if (vc_akcipher_req->opcode != VIRTIO_CRYPTO_AKCIPHER_VERIFY) { 98 /* actuall length maybe less than dst buffer */ 99 akcipher_req->dst_len = len - sizeof(vc_req->status); 100 sg_copy_from_buffer(akcipher_req->dst, sg_nents(akcipher_req->dst), 101 vc_akcipher_req->dst_buf, akcipher_req->dst_len); 102 } 103 virtio_crypto_akcipher_finalize_req(vc_akcipher_req, akcipher_req, error); 104 } 105 106 static int virtio_crypto_alg_akcipher_init_session(struct virtio_crypto_akcipher_ctx *ctx, 107 struct virtio_crypto_ctrl_header *header, 108 struct virtio_crypto_akcipher_session_para *para, 109 const uint8_t *key, unsigned int keylen) 110 { 111 struct scatterlist outhdr_sg, key_sg, inhdr_sg, *sgs[3]; 112 struct virtio_crypto *vcrypto = ctx->vcrypto; 113 uint8_t *pkey; 114 int err; 115 unsigned int num_out = 0, num_in = 0; 116 struct virtio_crypto_op_ctrl_req *ctrl; 117 struct virtio_crypto_session_input *input; 118 struct virtio_crypto_ctrl_request *vc_ctrl_req; 119 120 pkey = kmemdup(key, keylen, GFP_KERNEL); 121 if (!pkey) 122 return -ENOMEM; 123 124 vc_ctrl_req = kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); 125 if (!vc_ctrl_req) { 126 err = -ENOMEM; 127 goto out; 128 } 129 130 ctrl = &vc_ctrl_req->ctrl; 131 memcpy(&ctrl->header, header, sizeof(ctrl->header)); 132 memcpy(&ctrl->u.akcipher_create_session.para, para, sizeof(*para)); 133 input = &vc_ctrl_req->input; 134 input->status = cpu_to_le32(VIRTIO_CRYPTO_ERR); 135 136 sg_init_one(&outhdr_sg, ctrl, sizeof(*ctrl)); 137 sgs[num_out++] = &outhdr_sg; 138 139 sg_init_one(&key_sg, pkey, keylen); 140 sgs[num_out++] = &key_sg; 141 142 sg_init_one(&inhdr_sg, input, sizeof(*input)); 143 sgs[num_out + num_in++] = &inhdr_sg; 144 145 err = virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, num_in, vc_ctrl_req); 146 if (err < 0) 147 goto out; 148 149 if (le32_to_cpu(input->status) != VIRTIO_CRYPTO_OK) { 150 pr_err("virtio_crypto: Create session failed status: %u\n", 151 le32_to_cpu(input->status)); 152 err = -EINVAL; 153 goto out; 154 } 155 156 ctx->session_id = le64_to_cpu(input->session_id); 157 ctx->session_valid = true; 158 err = 0; 159 160 out: 161 kfree(vc_ctrl_req); 162 kfree_sensitive(pkey); 163 164 return err; 165 } 166 167 static int virtio_crypto_alg_akcipher_close_session(struct virtio_crypto_akcipher_ctx *ctx) 168 { 169 struct scatterlist outhdr_sg, inhdr_sg, *sgs[2]; 170 struct virtio_crypto_destroy_session_req *destroy_session; 171 struct virtio_crypto *vcrypto = ctx->vcrypto; 172 unsigned int num_out = 0, num_in = 0; 173 int err; 174 struct virtio_crypto_op_ctrl_req *ctrl; 175 struct virtio_crypto_inhdr *ctrl_status; 176 struct virtio_crypto_ctrl_request *vc_ctrl_req; 177 178 if (!ctx->session_valid) 179 return 0; 180 181 vc_ctrl_req = kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); 182 if (!vc_ctrl_req) 183 return -ENOMEM; 184 185 ctrl_status = &vc_ctrl_req->ctrl_status; 186 ctrl_status->status = VIRTIO_CRYPTO_ERR; 187 ctrl = &vc_ctrl_req->ctrl; 188 ctrl->header.opcode = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION); 189 ctrl->header.queue_id = 0; 190 191 destroy_session = &ctrl->u.destroy_session; 192 destroy_session->session_id = cpu_to_le64(ctx->session_id); 193 194 sg_init_one(&outhdr_sg, ctrl, sizeof(*ctrl)); 195 sgs[num_out++] = &outhdr_sg; 196 197 sg_init_one(&inhdr_sg, &ctrl_status->status, sizeof(ctrl_status->status)); 198 sgs[num_out + num_in++] = &inhdr_sg; 199 200 err = virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, num_in, vc_ctrl_req); 201 if (err < 0) 202 goto out; 203 204 if (ctrl_status->status != VIRTIO_CRYPTO_OK) { 205 pr_err("virtio_crypto: Close session failed status: %u, session_id: 0x%llx\n", 206 ctrl_status->status, destroy_session->session_id); 207 err = -EINVAL; 208 goto out; 209 } 210 211 err = 0; 212 ctx->session_valid = false; 213 214 out: 215 kfree(vc_ctrl_req); 216 217 return err; 218 } 219 220 static int __virtio_crypto_akcipher_do_req(struct virtio_crypto_akcipher_request *vc_akcipher_req, 221 struct akcipher_request *req, struct data_queue *data_vq) 222 { 223 struct virtio_crypto_akcipher_ctx *ctx = vc_akcipher_req->akcipher_ctx; 224 struct virtio_crypto_request *vc_req = &vc_akcipher_req->base; 225 struct virtio_crypto *vcrypto = ctx->vcrypto; 226 struct virtio_crypto_op_data_req *req_data = vc_req->req_data; 227 struct scatterlist *sgs[4], outhdr_sg, inhdr_sg, srcdata_sg, dstdata_sg; 228 void *src_buf, *dst_buf = NULL; 229 unsigned int num_out = 0, num_in = 0; 230 int node = dev_to_node(&vcrypto->vdev->dev); 231 unsigned long flags; 232 int ret; 233 bool verify = vc_akcipher_req->opcode == VIRTIO_CRYPTO_AKCIPHER_VERIFY; 234 unsigned int src_len = verify ? req->src_len + req->dst_len : req->src_len; 235 236 /* out header */ 237 sg_init_one(&outhdr_sg, req_data, sizeof(*req_data)); 238 sgs[num_out++] = &outhdr_sg; 239 240 /* src data */ 241 src_buf = kcalloc_node(src_len, 1, GFP_KERNEL, node); 242 if (!src_buf) 243 return -ENOMEM; 244 245 if (verify) { 246 /* for verify operation, both src and dst data work as OUT direction */ 247 sg_copy_to_buffer(req->src, sg_nents(req->src), src_buf, src_len); 248 sg_init_one(&srcdata_sg, src_buf, src_len); 249 sgs[num_out++] = &srcdata_sg; 250 } else { 251 sg_copy_to_buffer(req->src, sg_nents(req->src), src_buf, src_len); 252 sg_init_one(&srcdata_sg, src_buf, src_len); 253 sgs[num_out++] = &srcdata_sg; 254 255 /* dst data */ 256 dst_buf = kcalloc_node(req->dst_len, 1, GFP_KERNEL, node); 257 if (!dst_buf) 258 goto free_src; 259 260 sg_init_one(&dstdata_sg, dst_buf, req->dst_len); 261 sgs[num_out + num_in++] = &dstdata_sg; 262 } 263 264 vc_akcipher_req->src_buf = src_buf; 265 vc_akcipher_req->dst_buf = dst_buf; 266 267 /* in header */ 268 sg_init_one(&inhdr_sg, &vc_req->status, sizeof(vc_req->status)); 269 sgs[num_out + num_in++] = &inhdr_sg; 270 271 spin_lock_irqsave(&data_vq->lock, flags); 272 ret = virtqueue_add_sgs(data_vq->vq, sgs, num_out, num_in, vc_req, GFP_ATOMIC); 273 virtqueue_kick(data_vq->vq); 274 spin_unlock_irqrestore(&data_vq->lock, flags); 275 if (ret) 276 goto err; 277 278 return 0; 279 280 err: 281 kfree(dst_buf); 282 free_src: 283 kfree(src_buf); 284 return -ENOMEM; 285 } 286 287 static int virtio_crypto_rsa_do_req(struct crypto_engine *engine, void *vreq) 288 { 289 struct akcipher_request *req = container_of(vreq, struct akcipher_request, base); 290 struct virtio_crypto_akcipher_request *vc_akcipher_req = akcipher_request_ctx(req); 291 struct virtio_crypto_request *vc_req = &vc_akcipher_req->base; 292 struct virtio_crypto_akcipher_ctx *ctx = vc_akcipher_req->akcipher_ctx; 293 struct virtio_crypto *vcrypto = ctx->vcrypto; 294 struct data_queue *data_vq = vc_req->dataq; 295 struct virtio_crypto_op_header *header; 296 struct virtio_crypto_akcipher_data_req *akcipher_req; 297 int ret; 298 299 vc_req->sgs = NULL; 300 vc_req->req_data = kzalloc_node(sizeof(*vc_req->req_data), 301 GFP_KERNEL, dev_to_node(&vcrypto->vdev->dev)); 302 if (!vc_req->req_data) 303 return -ENOMEM; 304 305 /* build request header */ 306 header = &vc_req->req_data->header; 307 header->opcode = cpu_to_le32(vc_akcipher_req->opcode); 308 header->algo = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_RSA); 309 header->session_id = cpu_to_le64(ctx->session_id); 310 311 /* build request akcipher data */ 312 akcipher_req = &vc_req->req_data->u.akcipher_req; 313 akcipher_req->para.src_data_len = cpu_to_le32(req->src_len); 314 akcipher_req->para.dst_data_len = cpu_to_le32(req->dst_len); 315 316 ret = __virtio_crypto_akcipher_do_req(vc_akcipher_req, req, data_vq); 317 if (ret < 0) { 318 kfree_sensitive(vc_req->req_data); 319 vc_req->req_data = NULL; 320 return ret; 321 } 322 323 return 0; 324 } 325 326 static int virtio_crypto_rsa_req(struct akcipher_request *req, uint32_t opcode) 327 { 328 struct crypto_akcipher *atfm = crypto_akcipher_reqtfm(req); 329 struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(atfm); 330 struct virtio_crypto_akcipher_request *vc_akcipher_req = akcipher_request_ctx(req); 331 struct virtio_crypto_request *vc_req = &vc_akcipher_req->base; 332 struct virtio_crypto *vcrypto = ctx->vcrypto; 333 /* Use the first data virtqueue as default */ 334 struct data_queue *data_vq = &vcrypto->data_vq[0]; 335 336 vc_req->dataq = data_vq; 337 vc_req->alg_cb = virtio_crypto_dataq_akcipher_callback; 338 vc_akcipher_req->akcipher_ctx = ctx; 339 vc_akcipher_req->akcipher_req = req; 340 vc_akcipher_req->opcode = opcode; 341 342 return crypto_transfer_akcipher_request_to_engine(data_vq->engine, req); 343 } 344 345 static int virtio_crypto_rsa_encrypt(struct akcipher_request *req) 346 { 347 return virtio_crypto_rsa_req(req, VIRTIO_CRYPTO_AKCIPHER_ENCRYPT); 348 } 349 350 static int virtio_crypto_rsa_decrypt(struct akcipher_request *req) 351 { 352 return virtio_crypto_rsa_req(req, VIRTIO_CRYPTO_AKCIPHER_DECRYPT); 353 } 354 355 static int virtio_crypto_rsa_sign(struct akcipher_request *req) 356 { 357 return virtio_crypto_rsa_req(req, VIRTIO_CRYPTO_AKCIPHER_SIGN); 358 } 359 360 static int virtio_crypto_rsa_verify(struct akcipher_request *req) 361 { 362 return virtio_crypto_rsa_req(req, VIRTIO_CRYPTO_AKCIPHER_VERIFY); 363 } 364 365 static int virtio_crypto_rsa_set_key(struct crypto_akcipher *tfm, 366 const void *key, 367 unsigned int keylen, 368 bool private, 369 int padding_algo, 370 int hash_algo) 371 { 372 struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm); 373 struct virtio_crypto_rsa_ctx *rsa_ctx = &ctx->rsa_ctx; 374 struct virtio_crypto *vcrypto; 375 struct virtio_crypto_ctrl_header header; 376 struct virtio_crypto_akcipher_session_para para; 377 struct rsa_key rsa_key = {0}; 378 int node = virtio_crypto_get_current_node(); 379 uint32_t keytype; 380 int ret; 381 382 /* mpi_free will test n, just free it. */ 383 mpi_free(rsa_ctx->n); 384 rsa_ctx->n = NULL; 385 386 if (private) { 387 keytype = VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE; 388 ret = rsa_parse_priv_key(&rsa_key, key, keylen); 389 } else { 390 keytype = VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC; 391 ret = rsa_parse_pub_key(&rsa_key, key, keylen); 392 } 393 394 if (ret) 395 return ret; 396 397 rsa_ctx->n = mpi_read_raw_data(rsa_key.n, rsa_key.n_sz); 398 if (!rsa_ctx->n) 399 return -ENOMEM; 400 401 if (!ctx->vcrypto) { 402 vcrypto = virtcrypto_get_dev_node(node, VIRTIO_CRYPTO_SERVICE_AKCIPHER, 403 VIRTIO_CRYPTO_AKCIPHER_RSA); 404 if (!vcrypto) { 405 pr_err("virtio_crypto: Could not find a virtio device in the system or unsupported algo\n"); 406 return -ENODEV; 407 } 408 409 ctx->vcrypto = vcrypto; 410 } else { 411 virtio_crypto_alg_akcipher_close_session(ctx); 412 } 413 414 /* set ctrl header */ 415 header.opcode = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_CREATE_SESSION); 416 header.algo = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_RSA); 417 header.queue_id = 0; 418 419 /* set RSA para */ 420 para.algo = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_RSA); 421 para.keytype = cpu_to_le32(keytype); 422 para.keylen = cpu_to_le32(keylen); 423 para.u.rsa.padding_algo = cpu_to_le32(padding_algo); 424 para.u.rsa.hash_algo = cpu_to_le32(hash_algo); 425 426 return virtio_crypto_alg_akcipher_init_session(ctx, &header, ¶, key, keylen); 427 } 428 429 static int virtio_crypto_rsa_raw_set_priv_key(struct crypto_akcipher *tfm, 430 const void *key, 431 unsigned int keylen) 432 { 433 return virtio_crypto_rsa_set_key(tfm, key, keylen, 1, 434 VIRTIO_CRYPTO_RSA_RAW_PADDING, 435 VIRTIO_CRYPTO_RSA_NO_HASH); 436 } 437 438 439 static int virtio_crypto_p1pad_rsa_sha1_set_priv_key(struct crypto_akcipher *tfm, 440 const void *key, 441 unsigned int keylen) 442 { 443 return virtio_crypto_rsa_set_key(tfm, key, keylen, 1, 444 VIRTIO_CRYPTO_RSA_PKCS1_PADDING, 445 VIRTIO_CRYPTO_RSA_SHA1); 446 } 447 448 static int virtio_crypto_rsa_raw_set_pub_key(struct crypto_akcipher *tfm, 449 const void *key, 450 unsigned int keylen) 451 { 452 return virtio_crypto_rsa_set_key(tfm, key, keylen, 0, 453 VIRTIO_CRYPTO_RSA_RAW_PADDING, 454 VIRTIO_CRYPTO_RSA_NO_HASH); 455 } 456 457 static int virtio_crypto_p1pad_rsa_sha1_set_pub_key(struct crypto_akcipher *tfm, 458 const void *key, 459 unsigned int keylen) 460 { 461 return virtio_crypto_rsa_set_key(tfm, key, keylen, 0, 462 VIRTIO_CRYPTO_RSA_PKCS1_PADDING, 463 VIRTIO_CRYPTO_RSA_SHA1); 464 } 465 466 static unsigned int virtio_crypto_rsa_max_size(struct crypto_akcipher *tfm) 467 { 468 struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm); 469 struct virtio_crypto_rsa_ctx *rsa_ctx = &ctx->rsa_ctx; 470 471 return mpi_get_size(rsa_ctx->n); 472 } 473 474 static int virtio_crypto_rsa_init_tfm(struct crypto_akcipher *tfm) 475 { 476 struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm); 477 478 ctx->tfm = tfm; 479 480 akcipher_set_reqsize(tfm, 481 sizeof(struct virtio_crypto_akcipher_request)); 482 483 return 0; 484 } 485 486 static void virtio_crypto_rsa_exit_tfm(struct crypto_akcipher *tfm) 487 { 488 struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm); 489 struct virtio_crypto_rsa_ctx *rsa_ctx = &ctx->rsa_ctx; 490 491 virtio_crypto_alg_akcipher_close_session(ctx); 492 virtcrypto_dev_put(ctx->vcrypto); 493 mpi_free(rsa_ctx->n); 494 rsa_ctx->n = NULL; 495 } 496 497 static struct virtio_crypto_akcipher_algo virtio_crypto_akcipher_algs[] = { 498 { 499 .algonum = VIRTIO_CRYPTO_AKCIPHER_RSA, 500 .service = VIRTIO_CRYPTO_SERVICE_AKCIPHER, 501 .algo.base = { 502 .encrypt = virtio_crypto_rsa_encrypt, 503 .decrypt = virtio_crypto_rsa_decrypt, 504 .set_pub_key = virtio_crypto_rsa_raw_set_pub_key, 505 .set_priv_key = virtio_crypto_rsa_raw_set_priv_key, 506 .max_size = virtio_crypto_rsa_max_size, 507 .init = virtio_crypto_rsa_init_tfm, 508 .exit = virtio_crypto_rsa_exit_tfm, 509 .base = { 510 .cra_name = "rsa", 511 .cra_driver_name = "virtio-crypto-rsa", 512 .cra_priority = 150, 513 .cra_module = THIS_MODULE, 514 .cra_ctxsize = sizeof(struct virtio_crypto_akcipher_ctx), 515 }, 516 }, 517 .algo.op = { 518 .do_one_request = virtio_crypto_rsa_do_req, 519 }, 520 }, 521 { 522 .algonum = VIRTIO_CRYPTO_AKCIPHER_RSA, 523 .service = VIRTIO_CRYPTO_SERVICE_AKCIPHER, 524 .algo.base = { 525 .encrypt = virtio_crypto_rsa_encrypt, 526 .decrypt = virtio_crypto_rsa_decrypt, 527 .sign = virtio_crypto_rsa_sign, 528 .verify = virtio_crypto_rsa_verify, 529 .set_pub_key = virtio_crypto_p1pad_rsa_sha1_set_pub_key, 530 .set_priv_key = virtio_crypto_p1pad_rsa_sha1_set_priv_key, 531 .max_size = virtio_crypto_rsa_max_size, 532 .init = virtio_crypto_rsa_init_tfm, 533 .exit = virtio_crypto_rsa_exit_tfm, 534 .base = { 535 .cra_name = "pkcs1pad(rsa,sha1)", 536 .cra_driver_name = "virtio-pkcs1-rsa-with-sha1", 537 .cra_priority = 150, 538 .cra_module = THIS_MODULE, 539 .cra_ctxsize = sizeof(struct virtio_crypto_akcipher_ctx), 540 }, 541 }, 542 .algo.op = { 543 .do_one_request = virtio_crypto_rsa_do_req, 544 }, 545 }, 546 }; 547 548 int virtio_crypto_akcipher_algs_register(struct virtio_crypto *vcrypto) 549 { 550 int ret = 0; 551 int i = 0; 552 553 mutex_lock(&algs_lock); 554 555 for (i = 0; i < ARRAY_SIZE(virtio_crypto_akcipher_algs); i++) { 556 uint32_t service = virtio_crypto_akcipher_algs[i].service; 557 uint32_t algonum = virtio_crypto_akcipher_algs[i].algonum; 558 559 if (!virtcrypto_algo_is_supported(vcrypto, service, algonum)) 560 continue; 561 562 if (virtio_crypto_akcipher_algs[i].active_devs == 0) { 563 ret = crypto_engine_register_akcipher(&virtio_crypto_akcipher_algs[i].algo); 564 if (ret) 565 goto unlock; 566 } 567 568 virtio_crypto_akcipher_algs[i].active_devs++; 569 dev_info(&vcrypto->vdev->dev, "Registered akcipher algo %s\n", 570 virtio_crypto_akcipher_algs[i].algo.base.base.cra_name); 571 } 572 573 unlock: 574 mutex_unlock(&algs_lock); 575 return ret; 576 } 577 578 void virtio_crypto_akcipher_algs_unregister(struct virtio_crypto *vcrypto) 579 { 580 int i = 0; 581 582 mutex_lock(&algs_lock); 583 584 for (i = 0; i < ARRAY_SIZE(virtio_crypto_akcipher_algs); i++) { 585 uint32_t service = virtio_crypto_akcipher_algs[i].service; 586 uint32_t algonum = virtio_crypto_akcipher_algs[i].algonum; 587 588 if (virtio_crypto_akcipher_algs[i].active_devs == 0 || 589 !virtcrypto_algo_is_supported(vcrypto, service, algonum)) 590 continue; 591 592 if (virtio_crypto_akcipher_algs[i].active_devs == 1) 593 crypto_engine_unregister_akcipher(&virtio_crypto_akcipher_algs[i].algo); 594 595 virtio_crypto_akcipher_algs[i].active_devs--; 596 } 597 598 mutex_unlock(&algs_lock); 599 } 600