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 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 56 crypto = g_new(CryptoDevBackendVhost, 1); 57 crypto->dev.max_queues = 1; 58 crypto->dev.nvqs = 1; 59 crypto->dev.vqs = crypto->vqs; 60 61 crypto->cc = options->cc; 62 63 crypto->dev.protocol_features = 0; 64 crypto->backend = -1; 65 66 /* vhost-user needs vq_index to initiate a specific queue pair */ 67 crypto->dev.vq_index = crypto->cc->queue_index * crypto->dev.nvqs; 68 69 r = vhost_dev_init(&crypto->dev, options->opaque, options->backend_type, 0); 70 if (r < 0) { 71 goto fail; 72 } 73 74 return crypto; 75 fail: 76 g_free(crypto); 77 return NULL; 78 } 79 80 static int 81 cryptodev_vhost_start_one(CryptoDevBackendVhost *crypto, 82 VirtIODevice *dev) 83 { 84 int r; 85 86 crypto->dev.nvqs = 1; 87 crypto->dev.vqs = crypto->vqs; 88 89 r = vhost_dev_enable_notifiers(&crypto->dev, dev); 90 if (r < 0) { 91 goto fail_notifiers; 92 } 93 94 r = vhost_dev_start(&crypto->dev, dev); 95 if (r < 0) { 96 goto fail_start; 97 } 98 99 return 0; 100 101 fail_start: 102 vhost_dev_disable_notifiers(&crypto->dev, dev); 103 fail_notifiers: 104 return r; 105 } 106 107 static void 108 cryptodev_vhost_stop_one(CryptoDevBackendVhost *crypto, 109 VirtIODevice *dev) 110 { 111 vhost_dev_stop(&crypto->dev, dev); 112 vhost_dev_disable_notifiers(&crypto->dev, dev); 113 } 114 115 CryptoDevBackendVhost * 116 cryptodev_get_vhost(CryptoDevBackendClient *cc, 117 CryptoDevBackend *b, 118 uint16_t queue) 119 { 120 CryptoDevBackendVhost *vhost_crypto = NULL; 121 122 if (!cc) { 123 return NULL; 124 } 125 126 switch (cc->type) { 127 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX) 128 case CRYPTODEV_BACKEND_TYPE_VHOST_USER: 129 vhost_crypto = cryptodev_vhost_user_get_vhost(cc, b, queue); 130 break; 131 #endif 132 default: 133 break; 134 } 135 136 return vhost_crypto; 137 } 138 139 static void 140 cryptodev_vhost_set_vq_index(CryptoDevBackendVhost *crypto, 141 int vq_index) 142 { 143 crypto->dev.vq_index = vq_index; 144 } 145 146 static int 147 vhost_set_vring_enable(CryptoDevBackendClient *cc, 148 CryptoDevBackend *b, 149 uint16_t queue, int enable) 150 { 151 CryptoDevBackendVhost *crypto = 152 cryptodev_get_vhost(cc, b, queue); 153 const VhostOps *vhost_ops; 154 155 cc->vring_enable = enable; 156 157 if (!crypto) { 158 return 0; 159 } 160 161 vhost_ops = crypto->dev.vhost_ops; 162 if (vhost_ops->vhost_set_vring_enable) { 163 return vhost_ops->vhost_set_vring_enable(&crypto->dev, enable); 164 } 165 166 return 0; 167 } 168 169 int cryptodev_vhost_start(VirtIODevice *dev, int total_queues) 170 { 171 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev); 172 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev))); 173 VirtioBusState *vbus = VIRTIO_BUS(qbus); 174 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus); 175 int r, e; 176 int i; 177 CryptoDevBackend *b = vcrypto->cryptodev; 178 CryptoDevBackendVhost *vhost_crypto; 179 CryptoDevBackendClient *cc; 180 181 if (!k->set_guest_notifiers) { 182 error_report("binding does not support guest notifiers"); 183 return -ENOSYS; 184 } 185 186 for (i = 0; i < total_queues; i++) { 187 cc = b->conf.peers.ccs[i]; 188 189 vhost_crypto = cryptodev_get_vhost(cc, b, i); 190 cryptodev_vhost_set_vq_index(vhost_crypto, i); 191 192 /* Suppress the masking guest notifiers on vhost user 193 * because vhost user doesn't interrupt masking/unmasking 194 * properly. 195 */ 196 if (cc->type == CRYPTODEV_BACKEND_TYPE_VHOST_USER) { 197 dev->use_guest_notifier_mask = false; 198 } 199 } 200 201 r = k->set_guest_notifiers(qbus->parent, total_queues, true); 202 if (r < 0) { 203 error_report("error binding guest notifier: %d", -r); 204 goto err; 205 } 206 207 for (i = 0; i < total_queues; i++) { 208 cc = b->conf.peers.ccs[i]; 209 210 vhost_crypto = cryptodev_get_vhost(cc, b, i); 211 r = cryptodev_vhost_start_one(vhost_crypto, dev); 212 213 if (r < 0) { 214 goto err_start; 215 } 216 217 if (cc->vring_enable) { 218 /* restore vring enable state */ 219 r = vhost_set_vring_enable(cc, b, i, cc->vring_enable); 220 221 if (r < 0) { 222 goto err_start; 223 } 224 } 225 } 226 227 return 0; 228 229 err_start: 230 while (--i >= 0) { 231 cc = b->conf.peers.ccs[i]; 232 vhost_crypto = cryptodev_get_vhost(cc, b, i); 233 cryptodev_vhost_stop_one(vhost_crypto, dev); 234 } 235 e = k->set_guest_notifiers(qbus->parent, total_queues, false); 236 if (e < 0) { 237 error_report("vhost guest notifier cleanup failed: %d", e); 238 } 239 err: 240 return r; 241 } 242 243 void cryptodev_vhost_stop(VirtIODevice *dev, int total_queues) 244 { 245 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev))); 246 VirtioBusState *vbus = VIRTIO_BUS(qbus); 247 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus); 248 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev); 249 CryptoDevBackend *b = vcrypto->cryptodev; 250 CryptoDevBackendVhost *vhost_crypto; 251 CryptoDevBackendClient *cc; 252 size_t i; 253 int r; 254 255 for (i = 0; i < total_queues; i++) { 256 cc = b->conf.peers.ccs[i]; 257 258 vhost_crypto = cryptodev_get_vhost(cc, b, i); 259 cryptodev_vhost_stop_one(vhost_crypto, dev); 260 } 261 262 r = k->set_guest_notifiers(qbus->parent, total_queues, false); 263 if (r < 0) { 264 error_report("vhost guest notifier cleanup failed: %d", r); 265 } 266 assert(r >= 0); 267 } 268 269 void cryptodev_vhost_virtqueue_mask(VirtIODevice *dev, 270 int queue, 271 int idx, bool mask) 272 { 273 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev); 274 CryptoDevBackend *b = vcrypto->cryptodev; 275 CryptoDevBackendVhost *vhost_crypto; 276 CryptoDevBackendClient *cc; 277 278 assert(queue < MAX_CRYPTO_QUEUE_NUM); 279 280 cc = b->conf.peers.ccs[queue]; 281 vhost_crypto = cryptodev_get_vhost(cc, b, queue); 282 283 vhost_virtqueue_mask(&vhost_crypto->dev, dev, idx, mask); 284 } 285 286 bool cryptodev_vhost_virtqueue_pending(VirtIODevice *dev, 287 int queue, int idx) 288 { 289 VirtIOCrypto *vcrypto = VIRTIO_CRYPTO(dev); 290 CryptoDevBackend *b = vcrypto->cryptodev; 291 CryptoDevBackendVhost *vhost_crypto; 292 CryptoDevBackendClient *cc; 293 294 assert(queue < MAX_CRYPTO_QUEUE_NUM); 295 296 cc = b->conf.peers.ccs[queue]; 297 vhost_crypto = cryptodev_get_vhost(cc, b, queue); 298 299 return vhost_virtqueue_pending(&vhost_crypto->dev, idx); 300 } 301 302 #else 303 uint64_t 304 cryptodev_vhost_get_max_queues(CryptoDevBackendVhost *crypto) 305 { 306 return 0; 307 } 308 309 void cryptodev_vhost_cleanup(CryptoDevBackendVhost *crypto) 310 { 311 } 312 313 struct CryptoDevBackendVhost * 314 cryptodev_vhost_init(CryptoDevBackendVhostOptions *options) 315 { 316 return NULL; 317 } 318 319 CryptoDevBackendVhost * 320 cryptodev_get_vhost(CryptoDevBackendClient *cc, 321 CryptoDevBackend *b, 322 uint16_t queue) 323 { 324 return NULL; 325 } 326 327 int cryptodev_vhost_start(VirtIODevice *dev, int total_queues) 328 { 329 return -1; 330 } 331 332 void cryptodev_vhost_stop(VirtIODevice *dev, int total_queues) 333 { 334 } 335 336 void cryptodev_vhost_virtqueue_mask(VirtIODevice *dev, 337 int queue, 338 int idx, bool mask) 339 { 340 } 341 342 bool cryptodev_vhost_virtqueue_pending(VirtIODevice *dev, 343 int queue, int idx) 344 { 345 return false; 346 } 347 #endif 348