Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20210921' into staging
[qemu.git] / 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);
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);
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