1 /*
2 * Virtio crypto Support
3 *
4 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
5 *
6 * Authors:
7 * Gonglei <arei.gonglei@huawei.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or
10 * (at your option) any later version. See the COPYING file in the
11 * top-level directory.
12 */
13
14 #include "qemu/osdep.h"
15 #include "qemu/iov.h"
16 #include "qemu/main-loop.h"
17 #include "qemu/module.h"
18 #include "qapi/error.h"
19 #include "qemu/error-report.h"
20
21 #include "hw/virtio/virtio.h"
22 #include "hw/virtio/virtio-crypto.h"
23 #include "hw/qdev-properties.h"
24 #include "standard-headers/linux/virtio_ids.h"
25 #include "system/cryptodev-vhost.h"
26
27 #define VIRTIO_CRYPTO_VM_VERSION 1
28
29 typedef struct VirtIOCryptoSessionReq {
30 VirtIODevice *vdev;
31 VirtQueue *vq;
32 VirtQueueElement *elem;
33 CryptoDevBackendSessionInfo info;
34 CryptoDevCompletionFunc cb;
35 } VirtIOCryptoSessionReq;
36
virtio_crypto_free_create_session_req(VirtIOCryptoSessionReq * sreq)37 static void virtio_crypto_free_create_session_req(VirtIOCryptoSessionReq *sreq)
38 {
39 switch (sreq->info.op_code) {
40 case VIRTIO_CRYPTO_CIPHER_CREATE_SESSION:
41 g_free(sreq->info.u.sym_sess_info.cipher_key);
42 g_free(sreq->info.u.sym_sess_info.auth_key);
43 break;
44
45 case VIRTIO_CRYPTO_AKCIPHER_CREATE_SESSION:
46 g_free(sreq->info.u.asym_sess_info.key);
47 break;
48
49 case VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION:
50 case VIRTIO_CRYPTO_HASH_DESTROY_SESSION:
51 case VIRTIO_CRYPTO_MAC_DESTROY_SESSION:
52 case VIRTIO_CRYPTO_AEAD_DESTROY_SESSION:
53 case VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION:
54 break;
55
56 default:
57 error_report("Unknown opcode: %u", sreq->info.op_code);
58 }
59 g_free(sreq);
60 }
61
62 /*
63 * Transfer virtqueue index to crypto queue index.
64 * The control virtqueue is after the data virtqueues
65 * so the input value doesn't need to be adjusted
66 */
virtio_crypto_vq2q(int queue_index)67 static inline int virtio_crypto_vq2q(int queue_index)
68 {
69 return queue_index;
70 }
71
72 static int
virtio_crypto_cipher_session_helper(VirtIODevice * vdev,CryptoDevBackendSymSessionInfo * info,struct virtio_crypto_cipher_session_para * cipher_para,struct iovec ** iov,unsigned int * out_num)73 virtio_crypto_cipher_session_helper(VirtIODevice *vdev,
74 CryptoDevBackendSymSessionInfo *info,
75 struct virtio_crypto_cipher_session_para *cipher_para,
76 struct iovec **iov, unsigned int *out_num)
77 {
78 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
79 unsigned int num = *out_num;
80
81 info->cipher_alg = ldl_le_p(&cipher_para->algo);
82 info->key_len = ldl_le_p(&cipher_para->keylen);
83 info->direction = ldl_le_p(&cipher_para->op);
84 DPRINTF("cipher_alg=%" PRIu32 ", info->direction=%" PRIu32 "\n",
85 info->cipher_alg, info->direction);
86
87 if (info->key_len > vcrypto->conf.max_cipher_key_len) {
88 error_report("virtio-crypto length of cipher key is too big: %u",
89 info->key_len);
90 return -VIRTIO_CRYPTO_ERR;
91 }
92 /* Get cipher key */
93 if (info->key_len > 0) {
94 size_t s;
95 DPRINTF("keylen=%" PRIu32 "\n", info->key_len);
96
97 info->cipher_key = g_malloc(info->key_len);
98 s = iov_to_buf(*iov, num, 0, info->cipher_key, info->key_len);
99 if (unlikely(s != info->key_len)) {
100 virtio_error(vdev, "virtio-crypto cipher key incorrect");
101 return -EFAULT;
102 }
103 iov_discard_front(iov, &num, info->key_len);
104 *out_num = num;
105 }
106
107 return 0;
108 }
109
110 static int
virtio_crypto_create_sym_session(VirtIOCrypto * vcrypto,struct virtio_crypto_sym_create_session_req * sess_req,uint32_t queue_id,uint32_t opcode,struct iovec * iov,unsigned int out_num,VirtIOCryptoSessionReq * sreq)111 virtio_crypto_create_sym_session(VirtIOCrypto *vcrypto,
112 struct virtio_crypto_sym_create_session_req *sess_req,
113 uint32_t queue_id,
114 uint32_t opcode,
115 struct iovec *iov, unsigned int out_num,
116 VirtIOCryptoSessionReq *sreq)
117 {
118 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
119 CryptoDevBackendSymSessionInfo *sym_info = &sreq->info.u.sym_sess_info;
120 int queue_index;
121 uint32_t op_type;
122 int ret;
123
124 op_type = ldl_le_p(&sess_req->op_type);
125 sreq->info.op_code = opcode;
126
127 sym_info = &sreq->info.u.sym_sess_info;
128 sym_info->op_type = op_type;
129
130 if (op_type == VIRTIO_CRYPTO_SYM_OP_CIPHER) {
131 ret = virtio_crypto_cipher_session_helper(vdev, sym_info,
132 &sess_req->u.cipher.para,
133 &iov, &out_num);
134 if (ret < 0) {
135 return ret;
136 }
137 } else if (op_type == VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) {
138 size_t s;
139 /* cipher part */
140 ret = virtio_crypto_cipher_session_helper(vdev, sym_info,
141 &sess_req->u.chain.para.cipher_param,
142 &iov, &out_num);
143 if (ret < 0) {
144 return ret;
145 }
146 /* hash part */
147 sym_info->alg_chain_order = ldl_le_p(
148 &sess_req->u.chain.para.alg_chain_order);
149 sym_info->add_len = ldl_le_p(&sess_req->u.chain.para.aad_len);
150 sym_info->hash_mode = ldl_le_p(&sess_req->u.chain.para.hash_mode);
151 if (sym_info->hash_mode == VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH) {
152 sym_info->hash_alg =
153 ldl_le_p(&sess_req->u.chain.para.u.mac_param.algo);
154 sym_info->auth_key_len = ldl_le_p(
155 &sess_req->u.chain.para.u.mac_param.auth_key_len);
156 sym_info->hash_result_len = ldl_le_p(
157 &sess_req->u.chain.para.u.mac_param.hash_result_len);
158 if (sym_info->auth_key_len > vcrypto->conf.max_auth_key_len) {
159 error_report("virtio-crypto length of auth key is too big: %u",
160 sym_info->auth_key_len);
161 return -VIRTIO_CRYPTO_ERR;
162 }
163 /* get auth key */
164 if (sym_info->auth_key_len > 0) {
165 sym_info->auth_key = g_malloc(sym_info->auth_key_len);
166 s = iov_to_buf(iov, out_num, 0, sym_info->auth_key,
167 sym_info->auth_key_len);
168 if (unlikely(s != sym_info->auth_key_len)) {
169 virtio_error(vdev,
170 "virtio-crypto authenticated key incorrect");
171 return -EFAULT;
172 }
173 iov_discard_front(&iov, &out_num, sym_info->auth_key_len);
174 }
175 } else if (sym_info->hash_mode == VIRTIO_CRYPTO_SYM_HASH_MODE_PLAIN) {
176 sym_info->hash_alg = ldl_le_p(
177 &sess_req->u.chain.para.u.hash_param.algo);
178 sym_info->hash_result_len = ldl_le_p(
179 &sess_req->u.chain.para.u.hash_param.hash_result_len);
180 } else {
181 /* VIRTIO_CRYPTO_SYM_HASH_MODE_NESTED */
182 error_report("unsupported hash mode");
183 return -VIRTIO_CRYPTO_NOTSUPP;
184 }
185 } else {
186 /* VIRTIO_CRYPTO_SYM_OP_NONE */
187 error_report("unsupported cipher op_type: VIRTIO_CRYPTO_SYM_OP_NONE");
188 return -VIRTIO_CRYPTO_NOTSUPP;
189 }
190
191 queue_index = virtio_crypto_vq2q(queue_id);
192 return cryptodev_backend_create_session(vcrypto->cryptodev, &sreq->info,
193 queue_index, sreq->cb, sreq);
194 }
195
196 static int
virtio_crypto_create_asym_session(VirtIOCrypto * vcrypto,struct virtio_crypto_akcipher_create_session_req * sess_req,uint32_t queue_id,uint32_t opcode,struct iovec * iov,unsigned int out_num,VirtIOCryptoSessionReq * sreq)197 virtio_crypto_create_asym_session(VirtIOCrypto *vcrypto,
198 struct virtio_crypto_akcipher_create_session_req *sess_req,
199 uint32_t queue_id, uint32_t opcode,
200 struct iovec *iov, unsigned int out_num,
201 VirtIOCryptoSessionReq *sreq)
202 {
203 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
204 CryptoDevBackendAsymSessionInfo *asym_info = &sreq->info.u.asym_sess_info;
205 int queue_index;
206 uint32_t algo, keytype, keylen;
207
208 sreq->info.op_code = opcode;
209 algo = ldl_le_p(&sess_req->para.algo);
210 keytype = ldl_le_p(&sess_req->para.keytype);
211 keylen = ldl_le_p(&sess_req->para.keylen);
212
213 if ((keytype != VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC)
214 && (keytype != VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE)) {
215 error_report("unsupported asym keytype: %d", keytype);
216 return -VIRTIO_CRYPTO_NOTSUPP;
217 }
218
219 if (keylen) {
220 asym_info->key = g_malloc(keylen);
221 if (iov_to_buf(iov, out_num, 0, asym_info->key, keylen) != keylen) {
222 virtio_error(vdev, "virtio-crypto asym key incorrect");
223 return -EFAULT;
224 }
225 iov_discard_front(&iov, &out_num, keylen);
226 }
227
228 asym_info = &sreq->info.u.asym_sess_info;
229 asym_info->algo = algo;
230 asym_info->keytype = keytype;
231 asym_info->keylen = keylen;
232 switch (asym_info->algo) {
233 case VIRTIO_CRYPTO_AKCIPHER_RSA:
234 asym_info->u.rsa.padding_algo =
235 ldl_le_p(&sess_req->para.u.rsa.padding_algo);
236 asym_info->u.rsa.hash_algo =
237 ldl_le_p(&sess_req->para.u.rsa.hash_algo);
238 break;
239
240 /* TODO DSA&ECDSA handling */
241
242 default:
243 return -VIRTIO_CRYPTO_ERR;
244 }
245
246 queue_index = virtio_crypto_vq2q(queue_id);
247 return cryptodev_backend_create_session(vcrypto->cryptodev, &sreq->info,
248 queue_index, sreq->cb, sreq);
249 }
250
251 static int
virtio_crypto_handle_close_session(VirtIOCrypto * vcrypto,struct virtio_crypto_destroy_session_req * close_sess_req,uint32_t queue_id,VirtIOCryptoSessionReq * sreq)252 virtio_crypto_handle_close_session(VirtIOCrypto *vcrypto,
253 struct virtio_crypto_destroy_session_req *close_sess_req,
254 uint32_t queue_id,
255 VirtIOCryptoSessionReq *sreq)
256 {
257 uint64_t session_id;
258
259 session_id = ldq_le_p(&close_sess_req->session_id);
260 DPRINTF("close session, id=%" PRIu64 "\n", session_id);
261
262 return cryptodev_backend_close_session(
263 vcrypto->cryptodev, session_id, queue_id, sreq->cb, sreq);
264 }
265
virtio_crypto_create_session_completion(void * opaque,int ret)266 static void virtio_crypto_create_session_completion(void *opaque, int ret)
267 {
268 VirtIOCryptoSessionReq *sreq = (VirtIOCryptoSessionReq *)opaque;
269 VirtQueue *vq = sreq->vq;
270 VirtQueueElement *elem = sreq->elem;
271 VirtIODevice *vdev = sreq->vdev;
272 struct virtio_crypto_session_input input;
273 struct iovec *in_iov = elem->in_sg;
274 unsigned in_num = elem->in_num;
275 size_t s;
276
277 memset(&input, 0, sizeof(input));
278 /* Serious errors, need to reset virtio crypto device */
279 if (ret == -EFAULT) {
280 virtqueue_detach_element(vq, elem, 0);
281 goto out;
282 } else if (ret == -VIRTIO_CRYPTO_NOTSUPP) {
283 stl_le_p(&input.status, VIRTIO_CRYPTO_NOTSUPP);
284 } else if (ret == -VIRTIO_CRYPTO_KEY_REJECTED) {
285 stl_le_p(&input.status, VIRTIO_CRYPTO_KEY_REJECTED);
286 } else if (ret != VIRTIO_CRYPTO_OK) {
287 stl_le_p(&input.status, VIRTIO_CRYPTO_ERR);
288 } else {
289 /* Set the session id */
290 stq_le_p(&input.session_id, sreq->info.session_id);
291 stl_le_p(&input.status, VIRTIO_CRYPTO_OK);
292 }
293
294 s = iov_from_buf(in_iov, in_num, 0, &input, sizeof(input));
295 if (unlikely(s != sizeof(input))) {
296 virtio_error(vdev, "virtio-crypto input incorrect");
297 virtqueue_detach_element(vq, elem, 0);
298 goto out;
299 }
300 virtqueue_push(vq, elem, sizeof(input));
301 virtio_notify(vdev, vq);
302
303 out:
304 g_free(elem);
305 virtio_crypto_free_create_session_req(sreq);
306 }
307
virtio_crypto_destroy_session_completion(void * opaque,int ret)308 static void virtio_crypto_destroy_session_completion(void *opaque, int ret)
309 {
310 VirtIOCryptoSessionReq *sreq = (VirtIOCryptoSessionReq *)opaque;
311 VirtQueue *vq = sreq->vq;
312 VirtQueueElement *elem = sreq->elem;
313 VirtIODevice *vdev = sreq->vdev;
314 struct iovec *in_iov = elem->in_sg;
315 unsigned in_num = elem->in_num;
316 uint8_t status;
317 size_t s;
318
319 if (ret < 0) {
320 status = VIRTIO_CRYPTO_ERR;
321 } else {
322 status = VIRTIO_CRYPTO_OK;
323 }
324 s = iov_from_buf(in_iov, in_num, 0, &status, sizeof(status));
325 if (unlikely(s != sizeof(status))) {
326 virtio_error(vdev, "virtio-crypto status incorrect");
327 virtqueue_detach_element(vq, elem, 0);
328 goto out;
329 }
330 virtqueue_push(vq, elem, sizeof(status));
331 virtio_notify(vdev, vq);
332
333 out:
334 g_free(elem);
335 g_free(sreq);
336 }
337
virtio_crypto_handle_ctrl(VirtIODevice * vdev,VirtQueue * vq)338 static void virtio_crypto_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
339 {
340 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
341 struct virtio_crypto_op_ctrl_req ctrl;
342 VirtQueueElement *elem;
343 VirtIOCryptoSessionReq *sreq;
344 unsigned out_num;
345 unsigned in_num;
346 uint32_t queue_id;
347 uint32_t opcode;
348 struct virtio_crypto_session_input input;
349 size_t s;
350 int ret;
351 struct iovec *out_iov;
352 struct iovec *in_iov;
353
354 for (;;) {
355 g_autofree struct iovec *out_iov_copy = NULL;
356
357 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
358 if (!elem) {
359 break;
360 }
361 if (elem->out_num < 1 || elem->in_num < 1) {
362 virtio_error(vdev, "virtio-crypto ctrl missing headers");
363 virtqueue_detach_element(vq, elem, 0);
364 g_free(elem);
365 break;
366 }
367
368 out_num = elem->out_num;
369 out_iov_copy = g_memdup2(elem->out_sg, sizeof(out_iov[0]) * out_num);
370 out_iov = out_iov_copy;
371
372 in_num = elem->in_num;
373 in_iov = elem->in_sg;
374
375 if (unlikely(iov_to_buf(out_iov, out_num, 0, &ctrl, sizeof(ctrl))
376 != sizeof(ctrl))) {
377 virtio_error(vdev, "virtio-crypto request ctrl_hdr too short");
378 virtqueue_detach_element(vq, elem, 0);
379 g_free(elem);
380 break;
381 }
382 iov_discard_front(&out_iov, &out_num, sizeof(ctrl));
383
384 opcode = ldl_le_p(&ctrl.header.opcode);
385 queue_id = ldl_le_p(&ctrl.header.queue_id);
386
387 sreq = g_new0(VirtIOCryptoSessionReq, 1);
388 sreq->vdev = vdev;
389 sreq->vq = vq;
390 sreq->elem = elem;
391
392 switch (opcode) {
393 case VIRTIO_CRYPTO_CIPHER_CREATE_SESSION:
394 sreq->cb = virtio_crypto_create_session_completion;
395 ret = virtio_crypto_create_sym_session(vcrypto,
396 &ctrl.u.sym_create_session,
397 queue_id, opcode,
398 out_iov, out_num,
399 sreq);
400 if (ret < 0) {
401 virtio_crypto_create_session_completion(sreq, ret);
402 }
403 break;
404
405 case VIRTIO_CRYPTO_AKCIPHER_CREATE_SESSION:
406 sreq->cb = virtio_crypto_create_session_completion;
407 ret = virtio_crypto_create_asym_session(vcrypto,
408 &ctrl.u.akcipher_create_session,
409 queue_id, opcode,
410 out_iov, out_num,
411 sreq);
412 if (ret < 0) {
413 virtio_crypto_create_session_completion(sreq, ret);
414 }
415 break;
416
417 case VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION:
418 case VIRTIO_CRYPTO_HASH_DESTROY_SESSION:
419 case VIRTIO_CRYPTO_MAC_DESTROY_SESSION:
420 case VIRTIO_CRYPTO_AEAD_DESTROY_SESSION:
421 case VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION:
422 sreq->cb = virtio_crypto_destroy_session_completion;
423 ret = virtio_crypto_handle_close_session(vcrypto,
424 &ctrl.u.destroy_session, queue_id,
425 sreq);
426 if (ret < 0) {
427 virtio_crypto_destroy_session_completion(sreq, ret);
428 }
429 break;
430
431 case VIRTIO_CRYPTO_HASH_CREATE_SESSION:
432 case VIRTIO_CRYPTO_MAC_CREATE_SESSION:
433 case VIRTIO_CRYPTO_AEAD_CREATE_SESSION:
434 default:
435 memset(&input, 0, sizeof(input));
436 error_report("virtio-crypto unsupported ctrl opcode: %d", opcode);
437 stl_le_p(&input.status, VIRTIO_CRYPTO_NOTSUPP);
438 s = iov_from_buf(in_iov, in_num, 0, &input, sizeof(input));
439 if (unlikely(s != sizeof(input))) {
440 virtio_error(vdev, "virtio-crypto input incorrect");
441 virtqueue_detach_element(vq, elem, 0);
442 } else {
443 virtqueue_push(vq, elem, sizeof(input));
444 virtio_notify(vdev, vq);
445 }
446 g_free(sreq);
447 g_free(elem);
448
449 break;
450 } /* end switch case */
451
452 } /* end for loop */
453 }
454
virtio_crypto_init_request(VirtIOCrypto * vcrypto,VirtQueue * vq,VirtIOCryptoReq * req)455 static void virtio_crypto_init_request(VirtIOCrypto *vcrypto, VirtQueue *vq,
456 VirtIOCryptoReq *req)
457 {
458 req->vcrypto = vcrypto;
459 req->vq = vq;
460 req->in = NULL;
461 req->in_iov = NULL;
462 req->in_num = 0;
463 req->in_len = 0;
464 req->flags = QCRYPTODEV_BACKEND_ALGO_TYPE__MAX;
465 memset(&req->op_info, 0x00, sizeof(req->op_info));
466 }
467
virtio_crypto_free_request(VirtIOCryptoReq * req)468 static void virtio_crypto_free_request(VirtIOCryptoReq *req)
469 {
470 if (!req) {
471 return;
472 }
473
474 if (req->flags == QCRYPTODEV_BACKEND_ALGO_TYPE_SYM) {
475 size_t max_len;
476 CryptoDevBackendSymOpInfo *op_info = req->op_info.u.sym_op_info;
477
478 if (op_info) {
479 max_len = op_info->iv_len +
480 op_info->aad_len +
481 op_info->src_len +
482 op_info->dst_len +
483 op_info->digest_result_len;
484
485 /* Zeroize and free request data structure */
486 memset(op_info, 0, sizeof(*op_info) + max_len);
487 g_free(op_info);
488 }
489 } else if (req->flags == QCRYPTODEV_BACKEND_ALGO_TYPE_ASYM) {
490 CryptoDevBackendAsymOpInfo *op_info = req->op_info.u.asym_op_info;
491 if (op_info) {
492 g_free(op_info->src);
493 g_free(op_info->dst);
494 memset(op_info, 0, sizeof(*op_info));
495 g_free(op_info);
496 }
497 }
498
499 g_free(req->in_iov);
500 g_free(req);
501 }
502
503 static void
virtio_crypto_sym_input_data_helper(VirtIODevice * vdev,VirtIOCryptoReq * req,uint32_t status,CryptoDevBackendSymOpInfo * sym_op_info)504 virtio_crypto_sym_input_data_helper(VirtIODevice *vdev,
505 VirtIOCryptoReq *req,
506 uint32_t status,
507 CryptoDevBackendSymOpInfo *sym_op_info)
508 {
509 size_t s, len;
510 struct iovec *in_iov = req->in_iov;
511
512 if (status != VIRTIO_CRYPTO_OK) {
513 return;
514 }
515
516 len = sym_op_info->src_len;
517 /* Save the cipher result */
518 s = iov_from_buf(in_iov, req->in_num, 0, sym_op_info->dst, len);
519 if (s != len) {
520 virtio_error(vdev, "virtio-crypto dest data incorrect");
521 return;
522 }
523
524 iov_discard_front(&in_iov, &req->in_num, len);
525
526 if (sym_op_info->op_type ==
527 VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) {
528 /* Save the digest result */
529 s = iov_from_buf(in_iov, req->in_num, 0,
530 sym_op_info->digest_result,
531 sym_op_info->digest_result_len);
532 if (s != sym_op_info->digest_result_len) {
533 virtio_error(vdev, "virtio-crypto digest result incorrect");
534 }
535 }
536 }
537
538 static void
virtio_crypto_akcipher_input_data_helper(VirtIODevice * vdev,VirtIOCryptoReq * req,int32_t status,CryptoDevBackendAsymOpInfo * asym_op_info)539 virtio_crypto_akcipher_input_data_helper(VirtIODevice *vdev,
540 VirtIOCryptoReq *req, int32_t status,
541 CryptoDevBackendAsymOpInfo *asym_op_info)
542 {
543 size_t s, len;
544 struct iovec *in_iov = req->in_iov;
545
546 if (status != VIRTIO_CRYPTO_OK) {
547 return;
548 }
549
550 len = asym_op_info->dst_len;
551 if (!len) {
552 return;
553 }
554
555 s = iov_from_buf(in_iov, req->in_num, 0, asym_op_info->dst, len);
556 if (s != len) {
557 virtio_error(vdev, "virtio-crypto asym dest data incorrect");
558 return;
559 }
560
561 iov_discard_front(&in_iov, &req->in_num, len);
562
563 /* For akcipher, dst_len may be changed after operation */
564 req->in_len = sizeof(struct virtio_crypto_inhdr) + asym_op_info->dst_len;
565 }
566
virtio_crypto_req_complete(void * opaque,int ret)567 static void virtio_crypto_req_complete(void *opaque, int ret)
568 {
569 VirtIOCryptoReq *req = (VirtIOCryptoReq *)opaque;
570 VirtIOCrypto *vcrypto = req->vcrypto;
571 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
572 uint8_t status = -ret;
573
574 if (req->flags == QCRYPTODEV_BACKEND_ALGO_TYPE_SYM) {
575 virtio_crypto_sym_input_data_helper(vdev, req, status,
576 req->op_info.u.sym_op_info);
577 } else if (req->flags == QCRYPTODEV_BACKEND_ALGO_TYPE_ASYM) {
578 virtio_crypto_akcipher_input_data_helper(vdev, req, status,
579 req->op_info.u.asym_op_info);
580 }
581 stb_p(&req->in->status, status);
582 virtqueue_push(req->vq, &req->elem, req->in_len);
583 virtio_notify(vdev, req->vq);
584 virtio_crypto_free_request(req);
585 }
586
587 static VirtIOCryptoReq *
virtio_crypto_get_request(VirtIOCrypto * s,VirtQueue * vq)588 virtio_crypto_get_request(VirtIOCrypto *s, VirtQueue *vq)
589 {
590 VirtIOCryptoReq *req = virtqueue_pop(vq, sizeof(VirtIOCryptoReq));
591
592 if (req) {
593 virtio_crypto_init_request(s, vq, req);
594 }
595 return req;
596 }
597
598 static CryptoDevBackendSymOpInfo *
virtio_crypto_sym_op_helper(VirtIODevice * vdev,struct virtio_crypto_cipher_para * cipher_para,struct virtio_crypto_alg_chain_data_para * alg_chain_para,struct iovec * iov,unsigned int out_num)599 virtio_crypto_sym_op_helper(VirtIODevice *vdev,
600 struct virtio_crypto_cipher_para *cipher_para,
601 struct virtio_crypto_alg_chain_data_para *alg_chain_para,
602 struct iovec *iov, unsigned int out_num)
603 {
604 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
605 CryptoDevBackendSymOpInfo *op_info;
606 uint32_t src_len = 0, dst_len = 0;
607 uint32_t iv_len = 0;
608 uint32_t aad_len = 0, hash_result_len = 0;
609 uint32_t hash_start_src_offset = 0, len_to_hash = 0;
610 uint32_t cipher_start_src_offset = 0, len_to_cipher = 0;
611
612 uint64_t max_len, curr_size = 0;
613 size_t s;
614
615 /* Plain cipher */
616 if (cipher_para) {
617 iv_len = ldl_le_p(&cipher_para->iv_len);
618 src_len = ldl_le_p(&cipher_para->src_data_len);
619 dst_len = ldl_le_p(&cipher_para->dst_data_len);
620 } else if (alg_chain_para) { /* Algorithm chain */
621 iv_len = ldl_le_p(&alg_chain_para->iv_len);
622 src_len = ldl_le_p(&alg_chain_para->src_data_len);
623 dst_len = ldl_le_p(&alg_chain_para->dst_data_len);
624
625 aad_len = ldl_le_p(&alg_chain_para->aad_len);
626 hash_result_len = ldl_le_p(&alg_chain_para->hash_result_len);
627 hash_start_src_offset = ldl_le_p(
628 &alg_chain_para->hash_start_src_offset);
629 cipher_start_src_offset = ldl_le_p(
630 &alg_chain_para->cipher_start_src_offset);
631 len_to_cipher = ldl_le_p(&alg_chain_para->len_to_cipher);
632 len_to_hash = ldl_le_p(&alg_chain_para->len_to_hash);
633 } else {
634 return NULL;
635 }
636
637 if (unlikely(src_len != dst_len)) {
638 virtio_error(vdev, "sym request src len is different from dst len");
639 return NULL;
640 }
641
642 max_len = (uint64_t)iv_len + aad_len + src_len + dst_len + hash_result_len;
643 if (unlikely(max_len > vcrypto->conf.max_size)) {
644 virtio_error(vdev, "virtio-crypto too big length");
645 return NULL;
646 }
647
648 op_info = g_malloc0(sizeof(CryptoDevBackendSymOpInfo) + max_len);
649 op_info->iv_len = iv_len;
650 op_info->src_len = src_len;
651 op_info->dst_len = dst_len;
652 op_info->aad_len = aad_len;
653 op_info->digest_result_len = hash_result_len;
654 op_info->hash_start_src_offset = hash_start_src_offset;
655 op_info->len_to_hash = len_to_hash;
656 op_info->cipher_start_src_offset = cipher_start_src_offset;
657 op_info->len_to_cipher = len_to_cipher;
658 /* Handle the initialization vector */
659 if (op_info->iv_len > 0) {
660 DPRINTF("iv_len=%" PRIu32 "\n", op_info->iv_len);
661 op_info->iv = op_info->data + curr_size;
662
663 s = iov_to_buf(iov, out_num, 0, op_info->iv, op_info->iv_len);
664 if (unlikely(s != op_info->iv_len)) {
665 virtio_error(vdev, "virtio-crypto iv incorrect");
666 goto err;
667 }
668 iov_discard_front(&iov, &out_num, op_info->iv_len);
669 curr_size += op_info->iv_len;
670 }
671
672 /* Handle additional authentication data if exists */
673 if (op_info->aad_len > 0) {
674 DPRINTF("aad_len=%" PRIu32 "\n", op_info->aad_len);
675 op_info->aad_data = op_info->data + curr_size;
676
677 s = iov_to_buf(iov, out_num, 0, op_info->aad_data, op_info->aad_len);
678 if (unlikely(s != op_info->aad_len)) {
679 virtio_error(vdev, "virtio-crypto additional auth data incorrect");
680 goto err;
681 }
682 iov_discard_front(&iov, &out_num, op_info->aad_len);
683
684 curr_size += op_info->aad_len;
685 }
686
687 /* Handle the source data */
688 if (op_info->src_len > 0) {
689 DPRINTF("src_len=%" PRIu32 "\n", op_info->src_len);
690 op_info->src = op_info->data + curr_size;
691
692 s = iov_to_buf(iov, out_num, 0, op_info->src, op_info->src_len);
693 if (unlikely(s != op_info->src_len)) {
694 virtio_error(vdev, "virtio-crypto source data incorrect");
695 goto err;
696 }
697 iov_discard_front(&iov, &out_num, op_info->src_len);
698
699 curr_size += op_info->src_len;
700 }
701
702 /* Handle the destination data */
703 op_info->dst = op_info->data + curr_size;
704 curr_size += op_info->dst_len;
705
706 DPRINTF("dst_len=%" PRIu32 "\n", op_info->dst_len);
707
708 /* Handle the hash digest result */
709 if (hash_result_len > 0) {
710 DPRINTF("hash_result_len=%" PRIu32 "\n", hash_result_len);
711 op_info->digest_result = op_info->data + curr_size;
712 }
713
714 return op_info;
715
716 err:
717 g_free(op_info);
718 return NULL;
719 }
720
721 static int
virtio_crypto_handle_sym_req(VirtIOCrypto * vcrypto,struct virtio_crypto_sym_data_req * req,CryptoDevBackendOpInfo * op_info,struct iovec * iov,unsigned int out_num)722 virtio_crypto_handle_sym_req(VirtIOCrypto *vcrypto,
723 struct virtio_crypto_sym_data_req *req,
724 CryptoDevBackendOpInfo *op_info,
725 struct iovec *iov, unsigned int out_num)
726 {
727 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
728 CryptoDevBackendSymOpInfo *sym_op_info;
729 uint32_t op_type;
730
731 op_type = ldl_le_p(&req->op_type);
732 if (op_type == VIRTIO_CRYPTO_SYM_OP_CIPHER) {
733 sym_op_info = virtio_crypto_sym_op_helper(vdev, &req->u.cipher.para,
734 NULL, iov, out_num);
735 if (!sym_op_info) {
736 return -EFAULT;
737 }
738 } else if (op_type == VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) {
739 sym_op_info = virtio_crypto_sym_op_helper(vdev, NULL,
740 &req->u.chain.para,
741 iov, out_num);
742 if (!sym_op_info) {
743 return -EFAULT;
744 }
745 } else {
746 /* VIRTIO_CRYPTO_SYM_OP_NONE */
747 error_report("virtio-crypto unsupported cipher type");
748 return -VIRTIO_CRYPTO_NOTSUPP;
749 }
750
751 sym_op_info->op_type = op_type;
752 op_info->u.sym_op_info = sym_op_info;
753
754 return 0;
755 }
756
757 static int
virtio_crypto_handle_asym_req(VirtIOCrypto * vcrypto,struct virtio_crypto_akcipher_data_req * req,CryptoDevBackendOpInfo * op_info,struct iovec * iov,unsigned int out_num)758 virtio_crypto_handle_asym_req(VirtIOCrypto *vcrypto,
759 struct virtio_crypto_akcipher_data_req *req,
760 CryptoDevBackendOpInfo *op_info,
761 struct iovec *iov, unsigned int out_num)
762 {
763 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
764 CryptoDevBackendAsymOpInfo *asym_op_info;
765 uint32_t src_len;
766 uint32_t dst_len;
767 uint32_t len;
768 uint8_t *src = NULL;
769 uint8_t *dst = NULL;
770 uint64_t max_len;
771
772 asym_op_info = g_new0(CryptoDevBackendAsymOpInfo, 1);
773 src_len = ldl_le_p(&req->para.src_data_len);
774 dst_len = ldl_le_p(&req->para.dst_data_len);
775
776 max_len = (uint64_t)src_len + dst_len;
777 if (unlikely(max_len > vcrypto->conf.max_size)) {
778 virtio_error(vdev, "virtio-crypto asym request is too large");
779 goto err;
780 }
781
782 if (src_len > 0) {
783 src = g_malloc0(src_len);
784 len = iov_to_buf(iov, out_num, 0, src, src_len);
785 if (unlikely(len != src_len)) {
786 virtio_error(vdev, "virtio-crypto asym src data incorrect"
787 "expected %u, actual %u", src_len, len);
788 goto err;
789 }
790
791 iov_discard_front(&iov, &out_num, src_len);
792 }
793
794 if (dst_len > 0) {
795 dst = g_malloc0(dst_len);
796
797 if (op_info->op_code == VIRTIO_CRYPTO_AKCIPHER_VERIFY) {
798 len = iov_to_buf(iov, out_num, 0, dst, dst_len);
799 if (unlikely(len != dst_len)) {
800 virtio_error(vdev, "virtio-crypto asym dst data incorrect"
801 "expected %u, actual %u", dst_len, len);
802 goto err;
803 }
804
805 iov_discard_front(&iov, &out_num, dst_len);
806 }
807 }
808
809 asym_op_info->src_len = src_len;
810 asym_op_info->dst_len = dst_len;
811 asym_op_info->src = src;
812 asym_op_info->dst = dst;
813 op_info->u.asym_op_info = asym_op_info;
814
815 return 0;
816
817 err:
818 g_free(asym_op_info);
819 g_free(src);
820 g_free(dst);
821
822 return -EFAULT;
823 }
824
825 static int
virtio_crypto_handle_request(VirtIOCryptoReq * request)826 virtio_crypto_handle_request(VirtIOCryptoReq *request)
827 {
828 VirtIOCrypto *vcrypto = request->vcrypto;
829 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
830 VirtQueueElement *elem = &request->elem;
831 int queue_index = virtio_crypto_vq2q(virtio_get_queue_index(request->vq));
832 struct virtio_crypto_op_data_req req;
833 int ret;
834 g_autofree struct iovec *in_iov_copy = NULL;
835 g_autofree struct iovec *out_iov_copy = NULL;
836 struct iovec *in_iov;
837 struct iovec *out_iov;
838 unsigned in_num;
839 unsigned out_num;
840 uint32_t opcode;
841 CryptoDevBackendOpInfo *op_info = &request->op_info;
842
843 if (elem->out_num < 1 || elem->in_num < 1) {
844 virtio_error(vdev, "virtio-crypto dataq missing headers");
845 return -1;
846 }
847
848 out_num = elem->out_num;
849 out_iov_copy = g_memdup2(elem->out_sg, sizeof(out_iov[0]) * out_num);
850 out_iov = out_iov_copy;
851
852 in_num = elem->in_num;
853 in_iov_copy = g_memdup2(elem->in_sg, sizeof(in_iov[0]) * in_num);
854 in_iov = in_iov_copy;
855
856 if (unlikely(iov_to_buf(out_iov, out_num, 0, &req, sizeof(req))
857 != sizeof(req))) {
858 virtio_error(vdev, "virtio-crypto request outhdr too short");
859 return -1;
860 }
861 iov_discard_front(&out_iov, &out_num, sizeof(req));
862
863 if (in_iov[in_num - 1].iov_len <
864 sizeof(struct virtio_crypto_inhdr)) {
865 virtio_error(vdev, "virtio-crypto request inhdr too short");
866 return -1;
867 }
868 /* We always touch the last byte, so just see how big in_iov is. */
869 request->in_len = iov_size(in_iov, in_num);
870 request->in = (void *)in_iov[in_num - 1].iov_base
871 + in_iov[in_num - 1].iov_len
872 - sizeof(struct virtio_crypto_inhdr);
873 iov_discard_back(in_iov, &in_num, sizeof(struct virtio_crypto_inhdr));
874
875 /*
876 * The length of operation result, including dest_data
877 * and digest_result if exists.
878 */
879 request->in_num = in_num;
880 request->in_iov = in_iov;
881 /* now, we free the in_iov_copy inside virtio_crypto_free_request */
882 in_iov_copy = NULL;
883
884 opcode = ldl_le_p(&req.header.opcode);
885 op_info->session_id = ldq_le_p(&req.header.session_id);
886 op_info->op_code = opcode;
887 op_info->queue_index = queue_index;
888 op_info->cb = virtio_crypto_req_complete;
889 op_info->opaque = request;
890
891 switch (opcode) {
892 case VIRTIO_CRYPTO_CIPHER_ENCRYPT:
893 case VIRTIO_CRYPTO_CIPHER_DECRYPT:
894 op_info->algtype = request->flags = QCRYPTODEV_BACKEND_ALGO_TYPE_SYM;
895 ret = virtio_crypto_handle_sym_req(vcrypto,
896 &req.u.sym_req, op_info,
897 out_iov, out_num);
898 goto check_result;
899
900 case VIRTIO_CRYPTO_AKCIPHER_ENCRYPT:
901 case VIRTIO_CRYPTO_AKCIPHER_DECRYPT:
902 case VIRTIO_CRYPTO_AKCIPHER_SIGN:
903 case VIRTIO_CRYPTO_AKCIPHER_VERIFY:
904 op_info->algtype = request->flags = QCRYPTODEV_BACKEND_ALGO_TYPE_ASYM;
905 ret = virtio_crypto_handle_asym_req(vcrypto,
906 &req.u.akcipher_req, op_info,
907 out_iov, out_num);
908
909 check_result:
910 /* Serious errors, need to reset virtio crypto device */
911 if (ret == -EFAULT) {
912 return -1;
913 } else if (ret == -VIRTIO_CRYPTO_NOTSUPP) {
914 virtio_crypto_req_complete(request, -VIRTIO_CRYPTO_NOTSUPP);
915 } else {
916 ret = cryptodev_backend_crypto_operation(vcrypto->cryptodev,
917 op_info);
918 if (ret < 0) {
919 virtio_crypto_req_complete(request, ret);
920 }
921 }
922 break;
923
924 case VIRTIO_CRYPTO_HASH:
925 case VIRTIO_CRYPTO_MAC:
926 case VIRTIO_CRYPTO_AEAD_ENCRYPT:
927 case VIRTIO_CRYPTO_AEAD_DECRYPT:
928 default:
929 error_report("virtio-crypto unsupported dataq opcode: %u",
930 opcode);
931 virtio_crypto_req_complete(request, -VIRTIO_CRYPTO_NOTSUPP);
932 }
933
934 return 0;
935 }
936
virtio_crypto_handle_dataq(VirtIODevice * vdev,VirtQueue * vq)937 static void virtio_crypto_handle_dataq(VirtIODevice *vdev, VirtQueue *vq)
938 {
939 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
940 VirtIOCryptoReq *req;
941
942 while ((req = virtio_crypto_get_request(vcrypto, vq))) {
943 if (virtio_crypto_handle_request(req) < 0) {
944 virtqueue_detach_element(req->vq, &req->elem, 0);
945 virtio_crypto_free_request(req);
946 break;
947 }
948 }
949 }
950
virtio_crypto_dataq_bh(void * opaque)951 static void virtio_crypto_dataq_bh(void *opaque)
952 {
953 VirtIOCryptoQueue *q = opaque;
954 VirtIOCrypto *vcrypto = q->vcrypto;
955 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
956
957 /* This happens when device was stopped but BH wasn't. */
958 if (!vdev->vm_running) {
959 return;
960 }
961
962 /* Just in case the driver is not ready on more */
963 if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
964 return;
965 }
966
967 for (;;) {
968 virtio_crypto_handle_dataq(vdev, q->dataq);
969 virtio_queue_set_notification(q->dataq, 1);
970
971 /* Are we done or did the guest add more buffers? */
972 if (virtio_queue_empty(q->dataq)) {
973 break;
974 }
975
976 virtio_queue_set_notification(q->dataq, 0);
977 }
978 }
979
980 static void
virtio_crypto_handle_dataq_bh(VirtIODevice * vdev,VirtQueue * vq)981 virtio_crypto_handle_dataq_bh(VirtIODevice *vdev, VirtQueue *vq)
982 {
983 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
984 VirtIOCryptoQueue *q =
985 &vcrypto->vqs[virtio_crypto_vq2q(virtio_get_queue_index(vq))];
986
987 /* This happens when device was stopped but VCPU wasn't. */
988 if (!vdev->vm_running) {
989 return;
990 }
991 virtio_queue_set_notification(vq, 0);
992 qemu_bh_schedule(q->dataq_bh);
993 }
994
virtio_crypto_get_features(VirtIODevice * vdev,uint64_t features,Error ** errp)995 static uint64_t virtio_crypto_get_features(VirtIODevice *vdev,
996 uint64_t features,
997 Error **errp)
998 {
999 return features;
1000 }
1001
virtio_crypto_reset(VirtIODevice * vdev)1002 static void virtio_crypto_reset(VirtIODevice *vdev)
1003 {
1004 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
1005 /* multiqueue is disabled by default */
1006 vcrypto->curr_queues = 1;
1007 if (!cryptodev_backend_is_ready(vcrypto->cryptodev)) {
1008 vcrypto->status &= ~VIRTIO_CRYPTO_S_HW_READY;
1009 } else {
1010 vcrypto->status |= VIRTIO_CRYPTO_S_HW_READY;
1011 }
1012 }
1013
virtio_crypto_init_services(uint32_t qservices)1014 static uint32_t virtio_crypto_init_services(uint32_t qservices)
1015 {
1016 uint32_t vservices = 0;
1017
1018 if (qservices & (1 << QCRYPTODEV_BACKEND_SERVICE_TYPE_CIPHER)) {
1019 vservices |= (1 << VIRTIO_CRYPTO_SERVICE_CIPHER);
1020 }
1021 if (qservices & (1 << QCRYPTODEV_BACKEND_SERVICE_TYPE_HASH)) {
1022 vservices |= (1 << VIRTIO_CRYPTO_SERVICE_HASH);
1023 }
1024 if (qservices & (1 << QCRYPTODEV_BACKEND_SERVICE_TYPE_MAC)) {
1025 vservices |= (1 << VIRTIO_CRYPTO_SERVICE_MAC);
1026 }
1027 if (qservices & (1 << QCRYPTODEV_BACKEND_SERVICE_TYPE_AEAD)) {
1028 vservices |= (1 << VIRTIO_CRYPTO_SERVICE_AEAD);
1029 }
1030 if (qservices & (1 << QCRYPTODEV_BACKEND_SERVICE_TYPE_AKCIPHER)) {
1031 vservices |= (1 << VIRTIO_CRYPTO_SERVICE_AKCIPHER);
1032 }
1033
1034 return vservices;
1035 }
1036
virtio_crypto_init_config(VirtIODevice * vdev)1037 static void virtio_crypto_init_config(VirtIODevice *vdev)
1038 {
1039 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
1040
1041 vcrypto->conf.crypto_services = virtio_crypto_init_services(
1042 vcrypto->conf.cryptodev->conf.crypto_services);
1043 vcrypto->conf.cipher_algo_l =
1044 vcrypto->conf.cryptodev->conf.cipher_algo_l;
1045 vcrypto->conf.cipher_algo_h =
1046 vcrypto->conf.cryptodev->conf.cipher_algo_h;
1047 vcrypto->conf.hash_algo = vcrypto->conf.cryptodev->conf.hash_algo;
1048 vcrypto->conf.mac_algo_l = vcrypto->conf.cryptodev->conf.mac_algo_l;
1049 vcrypto->conf.mac_algo_h = vcrypto->conf.cryptodev->conf.mac_algo_h;
1050 vcrypto->conf.aead_algo = vcrypto->conf.cryptodev->conf.aead_algo;
1051 vcrypto->conf.akcipher_algo = vcrypto->conf.cryptodev->conf.akcipher_algo;
1052 vcrypto->conf.max_cipher_key_len =
1053 vcrypto->conf.cryptodev->conf.max_cipher_key_len;
1054 vcrypto->conf.max_auth_key_len =
1055 vcrypto->conf.cryptodev->conf.max_auth_key_len;
1056 vcrypto->conf.max_size = vcrypto->conf.cryptodev->conf.max_size;
1057 }
1058
virtio_crypto_device_realize(DeviceState * dev,Error ** errp)1059 static void virtio_crypto_device_realize(DeviceState *dev, Error **errp)
1060 {
1061 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1062 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev);
1063 int i;
1064
1065 vcrypto->cryptodev = vcrypto->conf.cryptodev;
1066 if (vcrypto->cryptodev == NULL) {
1067 error_setg(errp, "'cryptodev' parameter expects a valid object");
1068 return;
1069 } else if (cryptodev_backend_is_used(vcrypto->cryptodev)) {
1070 error_setg(errp, "can't use already used cryptodev backend: %s",
1071 object_get_canonical_path_component(OBJECT(vcrypto->conf.cryptodev)));
1072 return;
1073 }
1074
1075 vcrypto->max_queues = MAX(vcrypto->cryptodev->conf.peers.queues, 1);
1076 if (vcrypto->max_queues + 1 > VIRTIO_QUEUE_MAX) {
1077 error_setg(errp, "Invalid number of queues (= %" PRIu32 "), "
1078 "must be a positive integer less than %d.",
1079 vcrypto->max_queues, VIRTIO_QUEUE_MAX);
1080 return;
1081 }
1082
1083 virtio_init(vdev, VIRTIO_ID_CRYPTO, vcrypto->config_size);
1084 vcrypto->curr_queues = 1;
1085 vcrypto->vqs = g_new0(VirtIOCryptoQueue, vcrypto->max_queues);
1086 for (i = 0; i < vcrypto->max_queues; i++) {
1087 vcrypto->vqs[i].dataq =
1088 virtio_add_queue(vdev, 1024, virtio_crypto_handle_dataq_bh);
1089 vcrypto->vqs[i].dataq_bh =
1090 virtio_bh_new_guarded(dev, virtio_crypto_dataq_bh,
1091 &vcrypto->vqs[i]);
1092 vcrypto->vqs[i].vcrypto = vcrypto;
1093 }
1094
1095 vcrypto->ctrl_vq = virtio_add_queue(vdev, 1024, virtio_crypto_handle_ctrl);
1096 if (!cryptodev_backend_is_ready(vcrypto->cryptodev)) {
1097 vcrypto->status &= ~VIRTIO_CRYPTO_S_HW_READY;
1098 } else {
1099 vcrypto->status |= VIRTIO_CRYPTO_S_HW_READY;
1100 }
1101
1102 virtio_crypto_init_config(vdev);
1103 cryptodev_backend_set_used(vcrypto->cryptodev, true);
1104 }
1105
virtio_crypto_device_unrealize(DeviceState * dev)1106 static void virtio_crypto_device_unrealize(DeviceState *dev)
1107 {
1108 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1109 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev);
1110 VirtIOCryptoQueue *q;
1111 int i, max_queues;
1112
1113 max_queues = vcrypto->multiqueue ? vcrypto->max_queues : 1;
1114 for (i = 0; i < max_queues; i++) {
1115 virtio_delete_queue(vcrypto->vqs[i].dataq);
1116 q = &vcrypto->vqs[i];
1117 qemu_bh_delete(q->dataq_bh);
1118 }
1119
1120 g_free(vcrypto->vqs);
1121 virtio_delete_queue(vcrypto->ctrl_vq);
1122
1123 virtio_cleanup(vdev);
1124 cryptodev_backend_set_used(vcrypto->cryptodev, false);
1125 }
1126
1127 static const VMStateDescription vmstate_virtio_crypto = {
1128 .name = "virtio-crypto",
1129 .unmigratable = 1,
1130 .minimum_version_id = VIRTIO_CRYPTO_VM_VERSION,
1131 .version_id = VIRTIO_CRYPTO_VM_VERSION,
1132 .fields = (const VMStateField[]) {
1133 VMSTATE_VIRTIO_DEVICE,
1134 VMSTATE_END_OF_LIST()
1135 },
1136 };
1137
1138 static const Property virtio_crypto_properties[] = {
1139 DEFINE_PROP_LINK("cryptodev", VirtIOCrypto, conf.cryptodev,
1140 TYPE_CRYPTODEV_BACKEND, CryptoDevBackend *),
1141 };
1142
virtio_crypto_get_config(VirtIODevice * vdev,uint8_t * config)1143 static void virtio_crypto_get_config(VirtIODevice *vdev, uint8_t *config)
1144 {
1145 VirtIOCrypto *c = VIRTIO_CRYPTO(vdev);
1146 struct virtio_crypto_config crypto_cfg = {};
1147
1148 /*
1149 * Virtio-crypto device conforms to VIRTIO 1.0 which is always LE,
1150 * so we can use LE accessors directly.
1151 */
1152 stl_le_p(&crypto_cfg.status, c->status);
1153 stl_le_p(&crypto_cfg.max_dataqueues, c->max_queues);
1154 stl_le_p(&crypto_cfg.crypto_services, c->conf.crypto_services);
1155 stl_le_p(&crypto_cfg.cipher_algo_l, c->conf.cipher_algo_l);
1156 stl_le_p(&crypto_cfg.cipher_algo_h, c->conf.cipher_algo_h);
1157 stl_le_p(&crypto_cfg.hash_algo, c->conf.hash_algo);
1158 stl_le_p(&crypto_cfg.mac_algo_l, c->conf.mac_algo_l);
1159 stl_le_p(&crypto_cfg.mac_algo_h, c->conf.mac_algo_h);
1160 stl_le_p(&crypto_cfg.aead_algo, c->conf.aead_algo);
1161 stl_le_p(&crypto_cfg.max_cipher_key_len, c->conf.max_cipher_key_len);
1162 stl_le_p(&crypto_cfg.max_auth_key_len, c->conf.max_auth_key_len);
1163 stq_le_p(&crypto_cfg.max_size, c->conf.max_size);
1164 stl_le_p(&crypto_cfg.akcipher_algo, c->conf.akcipher_algo);
1165
1166 memcpy(config, &crypto_cfg, c->config_size);
1167 }
1168
virtio_crypto_started(VirtIOCrypto * c,uint8_t status)1169 static bool virtio_crypto_started(VirtIOCrypto *c, uint8_t status)
1170 {
1171 VirtIODevice *vdev = VIRTIO_DEVICE(c);
1172 return (status & VIRTIO_CONFIG_S_DRIVER_OK) &&
1173 (c->status & VIRTIO_CRYPTO_S_HW_READY) && vdev->vm_running;
1174 }
1175
virtio_crypto_vhost_status(VirtIOCrypto * c,uint8_t status)1176 static void virtio_crypto_vhost_status(VirtIOCrypto *c, uint8_t status)
1177 {
1178 VirtIODevice *vdev = VIRTIO_DEVICE(c);
1179 int queues = c->multiqueue ? c->max_queues : 1;
1180 CryptoDevBackend *b = c->cryptodev;
1181 CryptoDevBackendClient *cc = b->conf.peers.ccs[0];
1182
1183 if (!cryptodev_get_vhost(cc, b, 0)) {
1184 return;
1185 }
1186
1187 if ((virtio_crypto_started(c, status)) == !!c->vhost_started) {
1188 return;
1189 }
1190
1191 if (!c->vhost_started) {
1192 int r;
1193
1194 c->vhost_started = 1;
1195 r = cryptodev_vhost_start(vdev, queues);
1196 if (r < 0) {
1197 error_report("unable to start vhost crypto: %d: "
1198 "falling back on userspace virtio", -r);
1199 c->vhost_started = 0;
1200 }
1201 } else {
1202 cryptodev_vhost_stop(vdev, queues);
1203 c->vhost_started = 0;
1204 }
1205 }
1206
virtio_crypto_set_status(VirtIODevice * vdev,uint8_t status)1207 static int virtio_crypto_set_status(VirtIODevice *vdev, uint8_t status)
1208 {
1209 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
1210
1211 virtio_crypto_vhost_status(vcrypto, status);
1212 return 0;
1213 }
1214
virtio_crypto_guest_notifier_mask(VirtIODevice * vdev,int idx,bool mask)1215 static void virtio_crypto_guest_notifier_mask(VirtIODevice *vdev, int idx,
1216 bool mask)
1217 {
1218 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
1219 int queue = virtio_crypto_vq2q(idx);
1220
1221 assert(vcrypto->vhost_started);
1222
1223 /*
1224 * Add the check for configure interrupt, Use VIRTIO_CONFIG_IRQ_IDX -1
1225 * as the macro of configure interrupt's IDX, If this driver does not
1226 * support, the function will return
1227 */
1228
1229 if (idx == VIRTIO_CONFIG_IRQ_IDX) {
1230 return;
1231 }
1232 cryptodev_vhost_virtqueue_mask(vdev, queue, idx, mask);
1233 }
1234
virtio_crypto_guest_notifier_pending(VirtIODevice * vdev,int idx)1235 static bool virtio_crypto_guest_notifier_pending(VirtIODevice *vdev, int idx)
1236 {
1237 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
1238 int queue = virtio_crypto_vq2q(idx);
1239
1240 assert(vcrypto->vhost_started);
1241
1242 /*
1243 * Add the check for configure interrupt, Use VIRTIO_CONFIG_IRQ_IDX -1
1244 * as the macro of configure interrupt's IDX, If this driver does not
1245 * support, the function will return
1246 */
1247
1248 if (idx == VIRTIO_CONFIG_IRQ_IDX) {
1249 return false;
1250 }
1251 return cryptodev_vhost_virtqueue_pending(vdev, queue, idx);
1252 }
1253
virtio_crypto_get_vhost(VirtIODevice * vdev)1254 static struct vhost_dev *virtio_crypto_get_vhost(VirtIODevice *vdev)
1255 {
1256 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
1257 CryptoDevBackend *b;
1258 CryptoDevBackendClient *cc;
1259 CryptoDevBackendVhost *vhost_crypto;
1260
1261 b = vcrypto->cryptodev;
1262 if (!b) {
1263 return NULL;
1264 }
1265
1266 cc = b->conf.peers.ccs[0];
1267 vhost_crypto = cryptodev_get_vhost(cc, b, 0);
1268 if (!vhost_crypto) {
1269 return NULL;
1270 }
1271
1272 return &vhost_crypto->dev;
1273 }
1274
virtio_crypto_class_init(ObjectClass * klass,const void * data)1275 static void virtio_crypto_class_init(ObjectClass *klass, const void *data)
1276 {
1277 DeviceClass *dc = DEVICE_CLASS(klass);
1278 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
1279
1280 device_class_set_props(dc, virtio_crypto_properties);
1281 dc->vmsd = &vmstate_virtio_crypto;
1282 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
1283 vdc->realize = virtio_crypto_device_realize;
1284 vdc->unrealize = virtio_crypto_device_unrealize;
1285 vdc->get_config = virtio_crypto_get_config;
1286 vdc->get_features = virtio_crypto_get_features;
1287 vdc->reset = virtio_crypto_reset;
1288 vdc->set_status = virtio_crypto_set_status;
1289 vdc->guest_notifier_mask = virtio_crypto_guest_notifier_mask;
1290 vdc->guest_notifier_pending = virtio_crypto_guest_notifier_pending;
1291 vdc->get_vhost = virtio_crypto_get_vhost;
1292 }
1293
virtio_crypto_instance_init(Object * obj)1294 static void virtio_crypto_instance_init(Object *obj)
1295 {
1296 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(obj);
1297
1298 /*
1299 * The default config_size is sizeof(struct virtio_crypto_config).
1300 * Can be overridden with virtio_crypto_set_config_size.
1301 */
1302 vcrypto->config_size = sizeof(struct virtio_crypto_config);
1303 }
1304
1305 static const TypeInfo virtio_crypto_info = {
1306 .name = TYPE_VIRTIO_CRYPTO,
1307 .parent = TYPE_VIRTIO_DEVICE,
1308 .instance_size = sizeof(VirtIOCrypto),
1309 .instance_init = virtio_crypto_instance_init,
1310 .class_init = virtio_crypto_class_init,
1311 };
1312
virtio_register_types(void)1313 static void virtio_register_types(void)
1314 {
1315 type_register_static(&virtio_crypto_info);
1316 }
1317
1318 type_init(virtio_register_types)
1319