backends/cryptodev-vhost.c

   1 /*
   2  * QEMU Cryptodev backend for QEMU cipher APIs
   3  *
   4  * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
   5  *
   6  * Authors:
   7  *    Gonglei <arei.gonglei@huawei.com>
   8  *    Jay Zhou <jianjay.zhou@huawei.com>
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  22  *
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "hw/virtio/virtio-bus.h"
  27 #include "sysemu/cryptodev-vhost.h"
  28
  29 #ifdef CONFIG_VHOST_CRYPTO
  30 #include "qapi/error.h"
  31 #include "qapi/qmp/qerror.h"
  32 #include "qemu/error-report.h"
  33 #include "hw/virtio/virtio-crypto.h"
  34 #include "sysemu/cryptodev-vhost-user.h"
  35
  36 uint64_t
  37 cryptodev_vhost_get_max_queues(
  38                         CryptoDevBackendVhost *crypto)
  39 {
  40     return crypto->dev.max_queues;
  41 }
  42
  43 void cryptodev_vhost_cleanup(CryptoDevBackendVhost *crypto)
  44 {
  45     vhost_dev_cleanup(&crypto->dev);
  46     g_free(crypto);
  47 }
  48
  49 struct CryptoDevBackendVhost *
  50 cryptodev_vhost_init(
  51              CryptoDevBackendVhostOptions *options)
  52 {
  53     int r;
  54     CryptoDevBackendVhost *crypto;
  55     Error *local_err = NULL;
  56
  57     crypto = g_new(CryptoDevBackendVhost, 1);
  58     crypto->dev.max_queues = 1;
  59     crypto->dev.nvqs = 1;
  60     crypto->dev.vqs = crypto->vqs;
  61
  62     crypto->cc = options->cc;
  63
  64     crypto->dev.protocol_features = 0;
  65     crypto->backend = -1;
  66
  67     /* vhost-user needs vq_index to initiate a specific queue pair */
  68     crypto->dev.vq_index = crypto->cc->queue_index * crypto->dev.nvqs;
  69
  70     r = vhost_dev_init(&crypto->dev, options->opaque, options->backend_type, 0,
  71                        &local_err);
  72     if (r < 0) {
  73         error_report_err(local_err);
  74         goto fail;
  75     }
  76
  77     return crypto;
  78 fail:
  79     g_free(crypto);
  80     return NULL;
  81 }
  82
  83 static int
  84 cryptodev_vhost_start_one(CryptoDevBackendVhost *crypto,
  85                                   VirtIODevice *dev)
  86 {
  87     int r;
  88
  89     crypto->dev.nvqs = 1;
  90     crypto->dev.vqs = crypto->vqs;
  91
  92     r = vhost_dev_enable_notifiers(&crypto->dev, dev);
  93     if (r < 0) {
  94         goto fail_notifiers;
  95     }
  96
  97     r = vhost_dev_start(&crypto->dev, dev, false);
  98     if (r < 0) {
  99         goto fail_start;
 100     }
 101
 102     return 0;
 103
 104 fail_start:
 105     vhost_dev_disable_notifiers(&crypto->dev, dev);
 106 fail_notifiers:
 107     return r;
 108 }
 109
 110 static void
 111 cryptodev_vhost_stop_one(CryptoDevBackendVhost *crypto,
 112                                  VirtIODevice *dev)
 113 {
 114     vhost_dev_stop(&crypto->dev, dev, false);
 115     vhost_dev_disable_notifiers(&crypto->dev, dev);
 116 }
 117
 118 CryptoDevBackendVhost *
 119 cryptodev_get_vhost(CryptoDevBackendClient *cc,
 120                             CryptoDevBackend *b,
 121                             uint16_t queue)
 122 {
 123     CryptoDevBackendVhost *vhost_crypto = NULL;
 124
 125     if (!cc) {
 126         return NULL;
 127     }
 128
 129     switch (cc->type) {
 130 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
 131     case CRYPTODEV_BACKEND_TYPE_VHOST_USER:
 132         vhost_crypto = cryptodev_vhost_user_get_vhost(cc, b, queue);
 133         break;
 134 #endif
 135     default:
 136         break;
 137     }
 138
 139     return vhost_crypto;
 140 }
 141
 142 static void
 143 cryptodev_vhost_set_vq_index(CryptoDevBackendVhost *crypto,
 144                                      int vq_index)
 145 {
 146     crypto->dev.vq_index = vq_index;
 147 }
 148
 149 static int
 150 vhost_set_vring_enable(CryptoDevBackendClient *cc,
 151                             CryptoDevBackend *b,
 152                             uint16_t queue, int enable)
 153 {
 154     CryptoDevBackendVhost *crypto =
 155                        cryptodev_get_vhost(cc, b, queue);
 156     const VhostOps *vhost_ops;
 157
 158     cc->vring_enable = enable;
 159
 160     if (!crypto) {
 161         return 0;
 162     }
 163
 164     vhost_ops = crypto->dev.vhost_ops;
 165     if (vhost_ops->vhost_set_vring_enable) {
 166         return vhost_ops->vhost_set_vring_enable(&crypto->dev, enable);
 167     }
 168
 169     return 0;
 170 }
 171
 172 int cryptodev_vhost_start(VirtIODevice *dev, int total_queues)
 173 {
 174     VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev);
 175     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
 176     VirtioBusState *vbus = VIRTIO_BUS(qbus);
 177     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
 178     int r, e;
 179     int i;
 180     CryptoDevBackend *b = vcrypto->cryptodev;
 181     CryptoDevBackendVhost *vhost_crypto;
 182     CryptoDevBackendClient *cc;
 183
 184     if (!k->set_guest_notifiers) {
 185         error_report("binding does not support guest notifiers");
 186         return -ENOSYS;
 187     }
 188
 189     for (i = 0; i < total_queues; i++) {
 190         cc = b->conf.peers.ccs[i];
 191
 192         vhost_crypto = cryptodev_get_vhost(cc, b, i);
 193         cryptodev_vhost_set_vq_index(vhost_crypto, i);
 194
 195         /* Suppress the masking guest notifiers on vhost user
 196          * because vhost user doesn't interrupt masking/unmasking
 197          * properly.
 198          */
 199         if (cc->type == CRYPTODEV_BACKEND_TYPE_VHOST_USER) {
 200             dev->use_guest_notifier_mask = false;
 201         }
 202      }
 203
 204     r = k->set_guest_notifiers(qbus->parent, total_queues, true);
 205     if (r < 0) {
 206         error_report("error binding guest notifier: %d", -r);
 207         goto err;
 208     }
 209
 210     for (i = 0; i < total_queues; i++) {
 211         cc = b->conf.peers.ccs[i];
 212
 213         vhost_crypto = cryptodev_get_vhost(cc, b, i);
 214         r = cryptodev_vhost_start_one(vhost_crypto, dev);
 215
 216         if (r < 0) {
 217             goto err_start;
 218         }
 219
 220         if (cc->vring_enable) {
 221             /* restore vring enable state */
 222             r = vhost_set_vring_enable(cc, b, i, cc->vring_enable);
 223
 224             if (r < 0) {
 225                 goto err_start;
 226             }
 227         }
 228     }
 229
 230     return 0;
 231
 232 err_start:
 233     while (--i >= 0) {
 234         cc = b->conf.peers.ccs[i];
 235         vhost_crypto = cryptodev_get_vhost(cc, b, i);
 236         cryptodev_vhost_stop_one(vhost_crypto, dev);
 237     }
 238     e = k->set_guest_notifiers(qbus->parent, total_queues, false);
 239     if (e < 0) {
 240         error_report("vhost guest notifier cleanup failed: %d", e);
 241     }
 242 err:
 243     return r;
 244 }
 245
 246 void cryptodev_vhost_stop(VirtIODevice *dev, int total_queues)
 247 {
 248     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
 249     VirtioBusState *vbus = VIRTIO_BUS(qbus);
 250     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
 251     VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev);
 252     CryptoDevBackend *b = vcrypto->cryptodev;
 253     CryptoDevBackendVhost *vhost_crypto;
 254     CryptoDevBackendClient *cc;
 255     size_t i;
 256     int r;
 257
 258     for (i = 0; i < total_queues; i++) {
 259         cc = b->conf.peers.ccs[i];
 260
 261         vhost_crypto = cryptodev_get_vhost(cc, b, i);
 262         cryptodev_vhost_stop_one(vhost_crypto, dev);
 263     }
 264
 265     r = k->set_guest_notifiers(qbus->parent, total_queues, false);
 266     if (r < 0) {
 267         error_report("vhost guest notifier cleanup failed: %d", r);
 268     }
 269     assert(r >= 0);
 270 }
 271
 272 void cryptodev_vhost_virtqueue_mask(VirtIODevice *dev,
 273                                            int queue,
 274                                            int idx, bool mask)
 275 {
 276     VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev);
 277     CryptoDevBackend *b = vcrypto->cryptodev;
 278     CryptoDevBackendVhost *vhost_crypto;
 279     CryptoDevBackendClient *cc;
 280
 281     assert(queue < MAX_CRYPTO_QUEUE_NUM);
 282
 283     cc = b->conf.peers.ccs[queue];
 284     vhost_crypto = cryptodev_get_vhost(cc, b, queue);
 285
 286     vhost_virtqueue_mask(&vhost_crypto->dev, dev, idx, mask);
 287 }
 288
 289 bool cryptodev_vhost_virtqueue_pending(VirtIODevice *dev,
 290                                               int queue, int idx)
 291 {
 292     VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev);
 293     CryptoDevBackend *b = vcrypto->cryptodev;
 294     CryptoDevBackendVhost *vhost_crypto;
 295     CryptoDevBackendClient *cc;
 296
 297     assert(queue < MAX_CRYPTO_QUEUE_NUM);
 298
 299     cc = b->conf.peers.ccs[queue];
 300     vhost_crypto = cryptodev_get_vhost(cc, b, queue);
 301
 302     return vhost_virtqueue_pending(&vhost_crypto->dev, idx);
 303 }
 304
 305 #else
 306 uint64_t
 307 cryptodev_vhost_get_max_queues(CryptoDevBackendVhost *crypto)
 308 {
 309     return 0;
 310 }
 311
 312 void cryptodev_vhost_cleanup(CryptoDevBackendVhost *crypto)
 313 {
 314 }
 315
 316 struct CryptoDevBackendVhost *
 317 cryptodev_vhost_init(CryptoDevBackendVhostOptions *options)
 318 {
 319     return NULL;
 320 }
 321
 322 CryptoDevBackendVhost *
 323 cryptodev_get_vhost(CryptoDevBackendClient *cc,
 324                     CryptoDevBackend *b,
 325                     uint16_t queue)
 326 {
 327     return NULL;
 328 }
 329
 330 int cryptodev_vhost_start(VirtIODevice *dev, int total_queues)
 331 {
 332     return -1;
 333 }
 334
 335 void cryptodev_vhost_stop(VirtIODevice *dev, int total_queues)
 336 {
 337 }
 338
 339 void cryptodev_vhost_virtqueue_mask(VirtIODevice *dev,
 340                                     int queue,
 341                                     int idx, bool mask)
 342 {
 343 }
 344
 345 bool cryptodev_vhost_virtqueue_pending(VirtIODevice *dev,
 346                                        int queue, int idx)
 347 {
 348     return false;
 349 }
 350 #endif