Merge remote-tracking branch 'remotes/stefanha/tags/tracing-pull-request' into staging
[qemu.git] / hw / virtio / virtio-crypto.c
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 #include "qemu/osdep.h"
14 #include "qemu/iov.h"
15 #include "hw/qdev.h"
16 #include "qapi/error.h"
17 #include "qemu/error-report.h"
18
19 #include "hw/virtio/virtio.h"
20 #include "hw/virtio/virtio-crypto.h"
21 #include "hw/virtio/virtio-access.h"
22 #include "standard-headers/linux/virtio_ids.h"
23
24 #define VIRTIO_CRYPTO_VM_VERSION 1
25
26 /*
27 * Transfer virtqueue index to crypto queue index.
28 * The control virtqueue is after the data virtqueues
29 * so the input value doesn't need to be adjusted
30 */
31 static inline int virtio_crypto_vq2q(int queue_index)
32 {
33 return queue_index;
34 }
35
36 static int
37 virtio_crypto_cipher_session_helper(VirtIODevice *vdev,
38 CryptoDevBackendSymSessionInfo *info,
39 struct virtio_crypto_cipher_session_para *cipher_para,
40 struct iovec **iov, unsigned int *out_num)
41 {
42 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
43 unsigned int num = *out_num;
44
45 info->cipher_alg = ldl_le_p(&cipher_para->algo);
46 info->key_len = ldl_le_p(&cipher_para->keylen);
47 info->direction = ldl_le_p(&cipher_para->op);
48 DPRINTF("cipher_alg=%" PRIu32 ", info->direction=%" PRIu32 "\n",
49 info->cipher_alg, info->direction);
50
51 if (info->key_len > vcrypto->conf.max_cipher_key_len) {
52 error_report("virtio-crypto length of cipher key is too big: %u",
53 info->key_len);
54 return -VIRTIO_CRYPTO_ERR;
55 }
56 /* Get cipher key */
57 if (info->key_len > 0) {
58 size_t s;
59 DPRINTF("keylen=%" PRIu32 "\n", info->key_len);
60
61 info->cipher_key = g_malloc(info->key_len);
62 s = iov_to_buf(*iov, num, 0, info->cipher_key, info->key_len);
63 if (unlikely(s != info->key_len)) {
64 virtio_error(vdev, "virtio-crypto cipher key incorrect");
65 return -EFAULT;
66 }
67 iov_discard_front(iov, &num, info->key_len);
68 *out_num = num;
69 }
70
71 return 0;
72 }
73
74 static int64_t
75 virtio_crypto_create_sym_session(VirtIOCrypto *vcrypto,
76 struct virtio_crypto_sym_create_session_req *sess_req,
77 uint32_t queue_id,
78 uint32_t opcode,
79 struct iovec *iov, unsigned int out_num)
80 {
81 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
82 CryptoDevBackendSymSessionInfo info;
83 int64_t session_id;
84 int queue_index;
85 uint32_t op_type;
86 Error *local_err = NULL;
87 int ret;
88
89 memset(&info, 0, sizeof(info));
90 op_type = ldl_le_p(&sess_req->op_type);
91 info.op_type = op_type;
92 info.op_code = opcode;
93
94 if (op_type == VIRTIO_CRYPTO_SYM_OP_CIPHER) {
95 ret = virtio_crypto_cipher_session_helper(vdev, &info,
96 &sess_req->u.cipher.para,
97 &iov, &out_num);
98 if (ret < 0) {
99 goto err;
100 }
101 } else if (op_type == VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) {
102 size_t s;
103 /* cipher part */
104 ret = virtio_crypto_cipher_session_helper(vdev, &info,
105 &sess_req->u.chain.para.cipher_param,
106 &iov, &out_num);
107 if (ret < 0) {
108 goto err;
109 }
110 /* hash part */
111 info.alg_chain_order = ldl_le_p(
112 &sess_req->u.chain.para.alg_chain_order);
113 info.add_len = ldl_le_p(&sess_req->u.chain.para.aad_len);
114 info.hash_mode = ldl_le_p(&sess_req->u.chain.para.hash_mode);
115 if (info.hash_mode == VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH) {
116 info.hash_alg = ldl_le_p(&sess_req->u.chain.para.u.mac_param.algo);
117 info.auth_key_len = ldl_le_p(
118 &sess_req->u.chain.para.u.mac_param.auth_key_len);
119 info.hash_result_len = ldl_le_p(
120 &sess_req->u.chain.para.u.mac_param.hash_result_len);
121 if (info.auth_key_len > vcrypto->conf.max_auth_key_len) {
122 error_report("virtio-crypto length of auth key is too big: %u",
123 info.auth_key_len);
124 ret = -VIRTIO_CRYPTO_ERR;
125 goto err;
126 }
127 /* get auth key */
128 if (info.auth_key_len > 0) {
129 DPRINTF("auth_keylen=%" PRIu32 "\n", info.auth_key_len);
130 info.auth_key = g_malloc(info.auth_key_len);
131 s = iov_to_buf(iov, out_num, 0, info.auth_key,
132 info.auth_key_len);
133 if (unlikely(s != info.auth_key_len)) {
134 virtio_error(vdev,
135 "virtio-crypto authenticated key incorrect");
136 ret = -EFAULT;
137 goto err;
138 }
139 iov_discard_front(&iov, &out_num, info.auth_key_len);
140 }
141 } else if (info.hash_mode == VIRTIO_CRYPTO_SYM_HASH_MODE_PLAIN) {
142 info.hash_alg = ldl_le_p(
143 &sess_req->u.chain.para.u.hash_param.algo);
144 info.hash_result_len = ldl_le_p(
145 &sess_req->u.chain.para.u.hash_param.hash_result_len);
146 } else {
147 /* VIRTIO_CRYPTO_SYM_HASH_MODE_NESTED */
148 error_report("unsupported hash mode");
149 ret = -VIRTIO_CRYPTO_NOTSUPP;
150 goto err;
151 }
152 } else {
153 /* VIRTIO_CRYPTO_SYM_OP_NONE */
154 error_report("unsupported cipher op_type: VIRTIO_CRYPTO_SYM_OP_NONE");
155 ret = -VIRTIO_CRYPTO_NOTSUPP;
156 goto err;
157 }
158
159 queue_index = virtio_crypto_vq2q(queue_id);
160 session_id = cryptodev_backend_sym_create_session(
161 vcrypto->cryptodev,
162 &info, queue_index, &local_err);
163 if (session_id >= 0) {
164 DPRINTF("create session_id=%" PRIu64 " successfully\n",
165 session_id);
166
167 ret = session_id;
168 } else {
169 if (local_err) {
170 error_report_err(local_err);
171 }
172 ret = -VIRTIO_CRYPTO_ERR;
173 }
174
175 err:
176 g_free(info.cipher_key);
177 g_free(info.auth_key);
178 return ret;
179 }
180
181 static uint8_t
182 virtio_crypto_handle_close_session(VirtIOCrypto *vcrypto,
183 struct virtio_crypto_destroy_session_req *close_sess_req,
184 uint32_t queue_id)
185 {
186 int ret;
187 uint64_t session_id;
188 uint32_t status;
189 Error *local_err = NULL;
190
191 session_id = ldq_le_p(&close_sess_req->session_id);
192 DPRINTF("close session, id=%" PRIu64 "\n", session_id);
193
194 ret = cryptodev_backend_sym_close_session(
195 vcrypto->cryptodev, session_id, queue_id, &local_err);
196 if (ret == 0) {
197 status = VIRTIO_CRYPTO_OK;
198 } else {
199 if (local_err) {
200 error_report_err(local_err);
201 } else {
202 error_report("destroy session failed");
203 }
204 status = VIRTIO_CRYPTO_ERR;
205 }
206
207 return status;
208 }
209
210 static void virtio_crypto_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
211 {
212 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
213 struct virtio_crypto_op_ctrl_req ctrl;
214 VirtQueueElement *elem;
215 struct iovec *in_iov;
216 struct iovec *out_iov;
217 unsigned in_num;
218 unsigned out_num;
219 uint32_t queue_id;
220 uint32_t opcode;
221 struct virtio_crypto_session_input input;
222 int64_t session_id;
223 uint8_t status;
224 size_t s;
225
226 for (;;) {
227 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
228 if (!elem) {
229 break;
230 }
231 if (elem->out_num < 1 || elem->in_num < 1) {
232 virtio_error(vdev, "virtio-crypto ctrl missing headers");
233 virtqueue_detach_element(vq, elem, 0);
234 g_free(elem);
235 break;
236 }
237
238 out_num = elem->out_num;
239 out_iov = elem->out_sg;
240 in_num = elem->in_num;
241 in_iov = elem->in_sg;
242 if (unlikely(iov_to_buf(out_iov, out_num, 0, &ctrl, sizeof(ctrl))
243 != sizeof(ctrl))) {
244 virtio_error(vdev, "virtio-crypto request ctrl_hdr too short");
245 virtqueue_detach_element(vq, elem, 0);
246 g_free(elem);
247 break;
248 }
249 iov_discard_front(&out_iov, &out_num, sizeof(ctrl));
250
251 opcode = ldl_le_p(&ctrl.header.opcode);
252 queue_id = ldl_le_p(&ctrl.header.queue_id);
253
254 switch (opcode) {
255 case VIRTIO_CRYPTO_CIPHER_CREATE_SESSION:
256 memset(&input, 0, sizeof(input));
257 session_id = virtio_crypto_create_sym_session(vcrypto,
258 &ctrl.u.sym_create_session,
259 queue_id, opcode,
260 out_iov, out_num);
261 /* Serious errors, need to reset virtio crypto device */
262 if (session_id == -EFAULT) {
263 virtqueue_detach_element(vq, elem, 0);
264 break;
265 } else if (session_id == -VIRTIO_CRYPTO_NOTSUPP) {
266 stl_le_p(&input.status, VIRTIO_CRYPTO_NOTSUPP);
267 } else if (session_id == -VIRTIO_CRYPTO_ERR) {
268 stl_le_p(&input.status, VIRTIO_CRYPTO_ERR);
269 } else {
270 /* Set the session id */
271 stq_le_p(&input.session_id, session_id);
272 stl_le_p(&input.status, VIRTIO_CRYPTO_OK);
273 }
274
275 s = iov_from_buf(in_iov, in_num, 0, &input, sizeof(input));
276 if (unlikely(s != sizeof(input))) {
277 virtio_error(vdev, "virtio-crypto input incorrect");
278 virtqueue_detach_element(vq, elem, 0);
279 break;
280 }
281 virtqueue_push(vq, elem, sizeof(input));
282 virtio_notify(vdev, vq);
283 break;
284 case VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION:
285 case VIRTIO_CRYPTO_HASH_DESTROY_SESSION:
286 case VIRTIO_CRYPTO_MAC_DESTROY_SESSION:
287 case VIRTIO_CRYPTO_AEAD_DESTROY_SESSION:
288 status = virtio_crypto_handle_close_session(vcrypto,
289 &ctrl.u.destroy_session, queue_id);
290 /* The status only occupy one byte, we can directly use it */
291 s = iov_from_buf(in_iov, in_num, 0, &status, sizeof(status));
292 if (unlikely(s != sizeof(status))) {
293 virtio_error(vdev, "virtio-crypto status incorrect");
294 virtqueue_detach_element(vq, elem, 0);
295 break;
296 }
297 virtqueue_push(vq, elem, sizeof(status));
298 virtio_notify(vdev, vq);
299 break;
300 case VIRTIO_CRYPTO_HASH_CREATE_SESSION:
301 case VIRTIO_CRYPTO_MAC_CREATE_SESSION:
302 case VIRTIO_CRYPTO_AEAD_CREATE_SESSION:
303 default:
304 error_report("virtio-crypto unsupported ctrl opcode: %d", opcode);
305 memset(&input, 0, sizeof(input));
306 stl_le_p(&input.status, VIRTIO_CRYPTO_NOTSUPP);
307 s = iov_from_buf(in_iov, in_num, 0, &input, sizeof(input));
308 if (unlikely(s != sizeof(input))) {
309 virtio_error(vdev, "virtio-crypto input incorrect");
310 virtqueue_detach_element(vq, elem, 0);
311 break;
312 }
313 virtqueue_push(vq, elem, sizeof(input));
314 virtio_notify(vdev, vq);
315
316 break;
317 } /* end switch case */
318
319 g_free(elem);
320 } /* end for loop */
321 }
322
323 static void virtio_crypto_init_request(VirtIOCrypto *vcrypto, VirtQueue *vq,
324 VirtIOCryptoReq *req)
325 {
326 req->vcrypto = vcrypto;
327 req->vq = vq;
328 req->in = NULL;
329 req->in_iov = NULL;
330 req->in_num = 0;
331 req->in_len = 0;
332 req->flags = CRYPTODEV_BACKEND_ALG__MAX;
333 req->u.sym_op_info = NULL;
334 }
335
336 static void virtio_crypto_free_request(VirtIOCryptoReq *req)
337 {
338 if (req) {
339 if (req->flags == CRYPTODEV_BACKEND_ALG_SYM) {
340 size_t max_len;
341 CryptoDevBackendSymOpInfo *op_info = req->u.sym_op_info;
342
343 max_len = op_info->iv_len +
344 op_info->aad_len +
345 op_info->src_len +
346 op_info->dst_len +
347 op_info->digest_result_len;
348
349 /* Zeroize and free request data structure */
350 memset(op_info, 0, sizeof(*op_info) + max_len);
351 g_free(op_info);
352 }
353 g_free(req);
354 }
355 }
356
357 static void
358 virtio_crypto_sym_input_data_helper(VirtIODevice *vdev,
359 VirtIOCryptoReq *req,
360 uint32_t status,
361 CryptoDevBackendSymOpInfo *sym_op_info)
362 {
363 size_t s, len;
364
365 if (status != VIRTIO_CRYPTO_OK) {
366 return;
367 }
368
369 len = sym_op_info->src_len;
370 /* Save the cipher result */
371 s = iov_from_buf(req->in_iov, req->in_num, 0, sym_op_info->dst, len);
372 if (s != len) {
373 virtio_error(vdev, "virtio-crypto dest data incorrect");
374 return;
375 }
376
377 iov_discard_front(&req->in_iov, &req->in_num, len);
378
379 if (sym_op_info->op_type ==
380 VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) {
381 /* Save the digest result */
382 s = iov_from_buf(req->in_iov, req->in_num, 0,
383 sym_op_info->digest_result,
384 sym_op_info->digest_result_len);
385 if (s != sym_op_info->digest_result_len) {
386 virtio_error(vdev, "virtio-crypto digest result incorrect");
387 }
388 }
389 }
390
391 static void virtio_crypto_req_complete(VirtIOCryptoReq *req, uint8_t status)
392 {
393 VirtIOCrypto *vcrypto = req->vcrypto;
394 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
395
396 if (req->flags == CRYPTODEV_BACKEND_ALG_SYM) {
397 virtio_crypto_sym_input_data_helper(vdev, req, status,
398 req->u.sym_op_info);
399 }
400 stb_p(&req->in->status, status);
401 virtqueue_push(req->vq, &req->elem, req->in_len);
402 virtio_notify(vdev, req->vq);
403 }
404
405 static VirtIOCryptoReq *
406 virtio_crypto_get_request(VirtIOCrypto *s, VirtQueue *vq)
407 {
408 VirtIOCryptoReq *req = virtqueue_pop(vq, sizeof(VirtIOCryptoReq));
409
410 if (req) {
411 virtio_crypto_init_request(s, vq, req);
412 }
413 return req;
414 }
415
416 static CryptoDevBackendSymOpInfo *
417 virtio_crypto_sym_op_helper(VirtIODevice *vdev,
418 struct virtio_crypto_cipher_para *cipher_para,
419 struct virtio_crypto_alg_chain_data_para *alg_chain_para,
420 struct iovec *iov, unsigned int out_num)
421 {
422 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
423 CryptoDevBackendSymOpInfo *op_info;
424 uint32_t src_len = 0, dst_len = 0;
425 uint32_t iv_len = 0;
426 uint32_t aad_len = 0, hash_result_len = 0;
427 uint32_t hash_start_src_offset = 0, len_to_hash = 0;
428 uint32_t cipher_start_src_offset = 0, len_to_cipher = 0;
429
430 uint64_t max_len, curr_size = 0;
431 size_t s;
432
433 /* Plain cipher */
434 if (cipher_para) {
435 iv_len = ldl_le_p(&cipher_para->iv_len);
436 src_len = ldl_le_p(&cipher_para->src_data_len);
437 dst_len = ldl_le_p(&cipher_para->dst_data_len);
438 } else if (alg_chain_para) { /* Algorithm chain */
439 iv_len = ldl_le_p(&alg_chain_para->iv_len);
440 src_len = ldl_le_p(&alg_chain_para->src_data_len);
441 dst_len = ldl_le_p(&alg_chain_para->dst_data_len);
442
443 aad_len = ldl_le_p(&alg_chain_para->aad_len);
444 hash_result_len = ldl_le_p(&alg_chain_para->hash_result_len);
445 hash_start_src_offset = ldl_le_p(
446 &alg_chain_para->hash_start_src_offset);
447 cipher_start_src_offset = ldl_le_p(
448 &alg_chain_para->cipher_start_src_offset);
449 len_to_cipher = ldl_le_p(&alg_chain_para->len_to_cipher);
450 len_to_hash = ldl_le_p(&alg_chain_para->len_to_hash);
451 } else {
452 return NULL;
453 }
454
455 max_len = (uint64_t)iv_len + aad_len + src_len + dst_len + hash_result_len;
456 if (unlikely(max_len > vcrypto->conf.max_size)) {
457 virtio_error(vdev, "virtio-crypto too big length");
458 return NULL;
459 }
460
461 op_info = g_malloc0(sizeof(CryptoDevBackendSymOpInfo) + max_len);
462 op_info->iv_len = iv_len;
463 op_info->src_len = src_len;
464 op_info->dst_len = dst_len;
465 op_info->aad_len = aad_len;
466 op_info->digest_result_len = hash_result_len;
467 op_info->hash_start_src_offset = hash_start_src_offset;
468 op_info->len_to_hash = len_to_hash;
469 op_info->cipher_start_src_offset = cipher_start_src_offset;
470 op_info->len_to_cipher = len_to_cipher;
471 /* Handle the initilization vector */
472 if (op_info->iv_len > 0) {
473 DPRINTF("iv_len=%" PRIu32 "\n", op_info->iv_len);
474 op_info->iv = op_info->data + curr_size;
475
476 s = iov_to_buf(iov, out_num, 0, op_info->iv, op_info->iv_len);
477 if (unlikely(s != op_info->iv_len)) {
478 virtio_error(vdev, "virtio-crypto iv incorrect");
479 goto err;
480 }
481 iov_discard_front(&iov, &out_num, op_info->iv_len);
482 curr_size += op_info->iv_len;
483 }
484
485 /* Handle additional authentication data if exists */
486 if (op_info->aad_len > 0) {
487 DPRINTF("aad_len=%" PRIu32 "\n", op_info->aad_len);
488 op_info->aad_data = op_info->data + curr_size;
489
490 s = iov_to_buf(iov, out_num, 0, op_info->aad_data, op_info->aad_len);
491 if (unlikely(s != op_info->aad_len)) {
492 virtio_error(vdev, "virtio-crypto additional auth data incorrect");
493 goto err;
494 }
495 iov_discard_front(&iov, &out_num, op_info->aad_len);
496
497 curr_size += op_info->aad_len;
498 }
499
500 /* Handle the source data */
501 if (op_info->src_len > 0) {
502 DPRINTF("src_len=%" PRIu32 "\n", op_info->src_len);
503 op_info->src = op_info->data + curr_size;
504
505 s = iov_to_buf(iov, out_num, 0, op_info->src, op_info->src_len);
506 if (unlikely(s != op_info->src_len)) {
507 virtio_error(vdev, "virtio-crypto source data incorrect");
508 goto err;
509 }
510 iov_discard_front(&iov, &out_num, op_info->src_len);
511
512 curr_size += op_info->src_len;
513 }
514
515 /* Handle the destination data */
516 op_info->dst = op_info->data + curr_size;
517 curr_size += op_info->dst_len;
518
519 DPRINTF("dst_len=%" PRIu32 "\n", op_info->dst_len);
520
521 /* Handle the hash digest result */
522 if (hash_result_len > 0) {
523 DPRINTF("hash_result_len=%" PRIu32 "\n", hash_result_len);
524 op_info->digest_result = op_info->data + curr_size;
525 }
526
527 return op_info;
528
529 err:
530 g_free(op_info);
531 return NULL;
532 }
533
534 static int
535 virtio_crypto_handle_sym_req(VirtIOCrypto *vcrypto,
536 struct virtio_crypto_sym_data_req *req,
537 CryptoDevBackendSymOpInfo **sym_op_info,
538 struct iovec *iov, unsigned int out_num)
539 {
540 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
541 uint32_t op_type;
542 CryptoDevBackendSymOpInfo *op_info;
543
544 op_type = ldl_le_p(&req->op_type);
545
546 if (op_type == VIRTIO_CRYPTO_SYM_OP_CIPHER) {
547 op_info = virtio_crypto_sym_op_helper(vdev, &req->u.cipher.para,
548 NULL, iov, out_num);
549 if (!op_info) {
550 return -EFAULT;
551 }
552 op_info->op_type = op_type;
553 } else if (op_type == VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) {
554 op_info = virtio_crypto_sym_op_helper(vdev, NULL,
555 &req->u.chain.para,
556 iov, out_num);
557 if (!op_info) {
558 return -EFAULT;
559 }
560 op_info->op_type = op_type;
561 } else {
562 /* VIRTIO_CRYPTO_SYM_OP_NONE */
563 error_report("virtio-crypto unsupported cipher type");
564 return -VIRTIO_CRYPTO_NOTSUPP;
565 }
566
567 *sym_op_info = op_info;
568
569 return 0;
570 }
571
572 static int
573 virtio_crypto_handle_request(VirtIOCryptoReq *request)
574 {
575 VirtIOCrypto *vcrypto = request->vcrypto;
576 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
577 VirtQueueElement *elem = &request->elem;
578 int queue_index = virtio_crypto_vq2q(virtio_get_queue_index(request->vq));
579 struct virtio_crypto_op_data_req req;
580 int ret;
581 struct iovec *in_iov;
582 struct iovec *out_iov;
583 unsigned in_num;
584 unsigned out_num;
585 uint32_t opcode;
586 uint8_t status = VIRTIO_CRYPTO_ERR;
587 uint64_t session_id;
588 CryptoDevBackendSymOpInfo *sym_op_info = NULL;
589 Error *local_err = NULL;
590
591 if (elem->out_num < 1 || elem->in_num < 1) {
592 virtio_error(vdev, "virtio-crypto dataq missing headers");
593 return -1;
594 }
595
596 out_num = elem->out_num;
597 out_iov = elem->out_sg;
598 in_num = elem->in_num;
599 in_iov = elem->in_sg;
600 if (unlikely(iov_to_buf(out_iov, out_num, 0, &req, sizeof(req))
601 != sizeof(req))) {
602 virtio_error(vdev, "virtio-crypto request outhdr too short");
603 return -1;
604 }
605 iov_discard_front(&out_iov, &out_num, sizeof(req));
606
607 if (in_iov[in_num - 1].iov_len <
608 sizeof(struct virtio_crypto_inhdr)) {
609 virtio_error(vdev, "virtio-crypto request inhdr too short");
610 return -1;
611 }
612 /* We always touch the last byte, so just see how big in_iov is. */
613 request->in_len = iov_size(in_iov, in_num);
614 request->in = (void *)in_iov[in_num - 1].iov_base
615 + in_iov[in_num - 1].iov_len
616 - sizeof(struct virtio_crypto_inhdr);
617 iov_discard_back(in_iov, &in_num, sizeof(struct virtio_crypto_inhdr));
618
619 /*
620 * The length of operation result, including dest_data
621 * and digest_result if exists.
622 */
623 request->in_num = in_num;
624 request->in_iov = in_iov;
625
626 opcode = ldl_le_p(&req.header.opcode);
627 session_id = ldq_le_p(&req.header.session_id);
628
629 switch (opcode) {
630 case VIRTIO_CRYPTO_CIPHER_ENCRYPT:
631 case VIRTIO_CRYPTO_CIPHER_DECRYPT:
632 ret = virtio_crypto_handle_sym_req(vcrypto,
633 &req.u.sym_req,
634 &sym_op_info,
635 out_iov, out_num);
636 /* Serious errors, need to reset virtio crypto device */
637 if (ret == -EFAULT) {
638 return -1;
639 } else if (ret == -VIRTIO_CRYPTO_NOTSUPP) {
640 virtio_crypto_req_complete(request, VIRTIO_CRYPTO_NOTSUPP);
641 virtio_crypto_free_request(request);
642 } else {
643 sym_op_info->session_id = session_id;
644
645 /* Set request's parameter */
646 request->flags = CRYPTODEV_BACKEND_ALG_SYM;
647 request->u.sym_op_info = sym_op_info;
648 ret = cryptodev_backend_crypto_operation(vcrypto->cryptodev,
649 request, queue_index, &local_err);
650 if (ret < 0) {
651 status = -ret;
652 if (local_err) {
653 error_report_err(local_err);
654 }
655 } else { /* ret == VIRTIO_CRYPTO_OK */
656 status = ret;
657 }
658 virtio_crypto_req_complete(request, status);
659 virtio_crypto_free_request(request);
660 }
661 break;
662 case VIRTIO_CRYPTO_HASH:
663 case VIRTIO_CRYPTO_MAC:
664 case VIRTIO_CRYPTO_AEAD_ENCRYPT:
665 case VIRTIO_CRYPTO_AEAD_DECRYPT:
666 default:
667 error_report("virtio-crypto unsupported dataq opcode: %u",
668 opcode);
669 virtio_crypto_req_complete(request, VIRTIO_CRYPTO_NOTSUPP);
670 virtio_crypto_free_request(request);
671 }
672
673 return 0;
674 }
675
676 static void virtio_crypto_handle_dataq(VirtIODevice *vdev, VirtQueue *vq)
677 {
678 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
679 VirtIOCryptoReq *req;
680
681 while ((req = virtio_crypto_get_request(vcrypto, vq))) {
682 if (virtio_crypto_handle_request(req) < 0) {
683 virtqueue_detach_element(req->vq, &req->elem, 0);
684 virtio_crypto_free_request(req);
685 break;
686 }
687 }
688 }
689
690 static void virtio_crypto_dataq_bh(void *opaque)
691 {
692 VirtIOCryptoQueue *q = opaque;
693 VirtIOCrypto *vcrypto = q->vcrypto;
694 VirtIODevice *vdev = VIRTIO_DEVICE(vcrypto);
695
696 /* This happens when device was stopped but BH wasn't. */
697 if (!vdev->vm_running) {
698 return;
699 }
700
701 /* Just in case the driver is not ready on more */
702 if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
703 return;
704 }
705
706 for (;;) {
707 virtio_crypto_handle_dataq(vdev, q->dataq);
708 virtio_queue_set_notification(q->dataq, 1);
709
710 /* Are we done or did the guest add more buffers? */
711 if (virtio_queue_empty(q->dataq)) {
712 break;
713 }
714
715 virtio_queue_set_notification(q->dataq, 0);
716 }
717 }
718
719 static void
720 virtio_crypto_handle_dataq_bh(VirtIODevice *vdev, VirtQueue *vq)
721 {
722 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
723 VirtIOCryptoQueue *q =
724 &vcrypto->vqs[virtio_crypto_vq2q(virtio_get_queue_index(vq))];
725
726 /* This happens when device was stopped but VCPU wasn't. */
727 if (!vdev->vm_running) {
728 return;
729 }
730 virtio_queue_set_notification(vq, 0);
731 qemu_bh_schedule(q->dataq_bh);
732 }
733
734 static uint64_t virtio_crypto_get_features(VirtIODevice *vdev,
735 uint64_t features,
736 Error **errp)
737 {
738 return features;
739 }
740
741 static void virtio_crypto_reset(VirtIODevice *vdev)
742 {
743 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
744 /* multiqueue is disabled by default */
745 vcrypto->curr_queues = 1;
746 if (!cryptodev_backend_is_ready(vcrypto->cryptodev)) {
747 vcrypto->status &= ~VIRTIO_CRYPTO_S_HW_READY;
748 } else {
749 vcrypto->status |= VIRTIO_CRYPTO_S_HW_READY;
750 }
751 }
752
753 static void virtio_crypto_init_config(VirtIODevice *vdev)
754 {
755 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(vdev);
756
757 vcrypto->conf.crypto_services =
758 vcrypto->conf.cryptodev->conf.crypto_services;
759 vcrypto->conf.cipher_algo_l =
760 vcrypto->conf.cryptodev->conf.cipher_algo_l;
761 vcrypto->conf.cipher_algo_h =
762 vcrypto->conf.cryptodev->conf.cipher_algo_h;
763 vcrypto->conf.hash_algo = vcrypto->conf.cryptodev->conf.hash_algo;
764 vcrypto->conf.mac_algo_l = vcrypto->conf.cryptodev->conf.mac_algo_l;
765 vcrypto->conf.mac_algo_h = vcrypto->conf.cryptodev->conf.mac_algo_h;
766 vcrypto->conf.aead_algo = vcrypto->conf.cryptodev->conf.aead_algo;
767 vcrypto->conf.max_cipher_key_len =
768 vcrypto->conf.cryptodev->conf.max_cipher_key_len;
769 vcrypto->conf.max_auth_key_len =
770 vcrypto->conf.cryptodev->conf.max_auth_key_len;
771 vcrypto->conf.max_size = vcrypto->conf.cryptodev->conf.max_size;
772 }
773
774 static void virtio_crypto_device_realize(DeviceState *dev, Error **errp)
775 {
776 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
777 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev);
778 int i;
779
780 vcrypto->cryptodev = vcrypto->conf.cryptodev;
781 if (vcrypto->cryptodev == NULL) {
782 error_setg(errp, "'cryptodev' parameter expects a valid object");
783 return;
784 }
785
786 vcrypto->max_queues = MAX(vcrypto->cryptodev->conf.peers.queues, 1);
787 if (vcrypto->max_queues + 1 > VIRTIO_QUEUE_MAX) {
788 error_setg(errp, "Invalid number of queues (= %" PRIu32 "), "
789 "must be a positive integer less than %d.",
790 vcrypto->max_queues, VIRTIO_QUEUE_MAX);
791 return;
792 }
793
794 virtio_init(vdev, "virtio-crypto", VIRTIO_ID_CRYPTO, vcrypto->config_size);
795 vcrypto->curr_queues = 1;
796 vcrypto->vqs = g_malloc0(sizeof(VirtIOCryptoQueue) * vcrypto->max_queues);
797 for (i = 0; i < vcrypto->max_queues; i++) {
798 vcrypto->vqs[i].dataq =
799 virtio_add_queue(vdev, 1024, virtio_crypto_handle_dataq_bh);
800 vcrypto->vqs[i].dataq_bh =
801 qemu_bh_new(virtio_crypto_dataq_bh, &vcrypto->vqs[i]);
802 vcrypto->vqs[i].vcrypto = vcrypto;
803 }
804
805 vcrypto->ctrl_vq = virtio_add_queue(vdev, 64, virtio_crypto_handle_ctrl);
806 if (!cryptodev_backend_is_ready(vcrypto->cryptodev)) {
807 vcrypto->status &= ~VIRTIO_CRYPTO_S_HW_READY;
808 } else {
809 vcrypto->status |= VIRTIO_CRYPTO_S_HW_READY;
810 }
811
812 virtio_crypto_init_config(vdev);
813 cryptodev_backend_set_used(vcrypto->cryptodev, true);
814 }
815
816 static void virtio_crypto_device_unrealize(DeviceState *dev, Error **errp)
817 {
818 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
819 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev);
820 VirtIOCryptoQueue *q;
821 int i, max_queues;
822
823 max_queues = vcrypto->multiqueue ? vcrypto->max_queues : 1;
824 for (i = 0; i < max_queues; i++) {
825 virtio_del_queue(vdev, i);
826 q = &vcrypto->vqs[i];
827 qemu_bh_delete(q->dataq_bh);
828 }
829
830 g_free(vcrypto->vqs);
831
832 virtio_cleanup(vdev);
833 cryptodev_backend_set_used(vcrypto->cryptodev, false);
834 }
835
836 static const VMStateDescription vmstate_virtio_crypto = {
837 .name = "virtio-crypto",
838 .unmigratable = 1,
839 .minimum_version_id = VIRTIO_CRYPTO_VM_VERSION,
840 .version_id = VIRTIO_CRYPTO_VM_VERSION,
841 .fields = (VMStateField[]) {
842 VMSTATE_VIRTIO_DEVICE,
843 VMSTATE_END_OF_LIST()
844 },
845 };
846
847 static Property virtio_crypto_properties[] = {
848 DEFINE_PROP_END_OF_LIST(),
849 };
850
851 static void virtio_crypto_get_config(VirtIODevice *vdev, uint8_t *config)
852 {
853 VirtIOCrypto *c = VIRTIO_CRYPTO(vdev);
854 struct virtio_crypto_config crypto_cfg = {};
855
856 /*
857 * Virtio-crypto device conforms to VIRTIO 1.0 which is always LE,
858 * so we can use LE accessors directly.
859 */
860 stl_le_p(&crypto_cfg.status, c->status);
861 stl_le_p(&crypto_cfg.max_dataqueues, c->max_queues);
862 stl_le_p(&crypto_cfg.crypto_services, c->conf.crypto_services);
863 stl_le_p(&crypto_cfg.cipher_algo_l, c->conf.cipher_algo_l);
864 stl_le_p(&crypto_cfg.cipher_algo_h, c->conf.cipher_algo_h);
865 stl_le_p(&crypto_cfg.hash_algo, c->conf.hash_algo);
866 stl_le_p(&crypto_cfg.mac_algo_l, c->conf.mac_algo_l);
867 stl_le_p(&crypto_cfg.mac_algo_h, c->conf.mac_algo_h);
868 stl_le_p(&crypto_cfg.aead_algo, c->conf.aead_algo);
869 stl_le_p(&crypto_cfg.max_cipher_key_len, c->conf.max_cipher_key_len);
870 stl_le_p(&crypto_cfg.max_auth_key_len, c->conf.max_auth_key_len);
871 stq_le_p(&crypto_cfg.max_size, c->conf.max_size);
872
873 memcpy(config, &crypto_cfg, c->config_size);
874 }
875
876 static void virtio_crypto_class_init(ObjectClass *klass, void *data)
877 {
878 DeviceClass *dc = DEVICE_CLASS(klass);
879 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
880
881 dc->props = virtio_crypto_properties;
882 dc->vmsd = &vmstate_virtio_crypto;
883 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
884 vdc->realize = virtio_crypto_device_realize;
885 vdc->unrealize = virtio_crypto_device_unrealize;
886 vdc->get_config = virtio_crypto_get_config;
887 vdc->get_features = virtio_crypto_get_features;
888 vdc->reset = virtio_crypto_reset;
889 }
890
891 static void
892 virtio_crypto_check_cryptodev_is_used(Object *obj, const char *name,
893 Object *val, Error **errp)
894 {
895 if (cryptodev_backend_is_used(CRYPTODEV_BACKEND(val))) {
896 char *path = object_get_canonical_path_component(val);
897 error_setg(errp,
898 "can't use already used cryptodev backend: %s", path);
899 g_free(path);
900 } else {
901 qdev_prop_allow_set_link_before_realize(obj, name, val, errp);
902 }
903 }
904
905 static void virtio_crypto_instance_init(Object *obj)
906 {
907 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(obj);
908
909 /*
910 * The default config_size is sizeof(struct virtio_crypto_config).
911 * Can be overriden with virtio_crypto_set_config_size.
912 */
913 vcrypto->config_size = sizeof(struct virtio_crypto_config);
914
915 object_property_add_link(obj, "cryptodev",
916 TYPE_CRYPTODEV_BACKEND,
917 (Object **)&vcrypto->conf.cryptodev,
918 virtio_crypto_check_cryptodev_is_used,
919 OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL);
920 }
921
922 static const TypeInfo virtio_crypto_info = {
923 .name = TYPE_VIRTIO_CRYPTO,
924 .parent = TYPE_VIRTIO_DEVICE,
925 .instance_size = sizeof(VirtIOCrypto),
926 .instance_init = virtio_crypto_instance_init,
927 .class_init = virtio_crypto_class_init,
928 };
929
930 static void virtio_register_types(void)
931 {
932 type_register_static(&virtio_crypto_info);
933 }
934
935 type_init(virtio_register_types)