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