capstone: Update to upstream "next" branch
[qemu.git] / hw / block / vhost-user-blk.c
1 /*
2 * vhost-user-blk host device
3 *
4 * Copyright(C) 2017 Intel Corporation.
5 *
6 * Authors:
7 * Changpeng Liu <changpeng.liu@intel.com>
8 *
9 * Largely based on the "vhost-user-scsi.c" and "vhost-scsi.c" implemented by:
10 * Felipe Franciosi <felipe@nutanix.com>
11 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
12 * Nicholas Bellinger <nab@risingtidesystems.com>
13 *
14 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
15 * See the COPYING.LIB file in the top-level directory.
16 *
17 */
18
19 #include "qemu/osdep.h"
20 #include "qapi/error.h"
21 #include "qemu/error-report.h"
22 #include "qemu/cutils.h"
23 #include "hw/qdev-core.h"
24 #include "hw/qdev-properties.h"
25 #include "hw/virtio/vhost.h"
26 #include "hw/virtio/vhost-user-blk.h"
27 #include "hw/virtio/virtio.h"
28 #include "hw/virtio/virtio-bus.h"
29 #include "hw/virtio/virtio-access.h"
30 #include "sysemu/sysemu.h"
31 #include "sysemu/runstate.h"
32
33 static const int user_feature_bits[] = {
34 VIRTIO_BLK_F_SIZE_MAX,
35 VIRTIO_BLK_F_SEG_MAX,
36 VIRTIO_BLK_F_GEOMETRY,
37 VIRTIO_BLK_F_BLK_SIZE,
38 VIRTIO_BLK_F_TOPOLOGY,
39 VIRTIO_BLK_F_MQ,
40 VIRTIO_BLK_F_RO,
41 VIRTIO_BLK_F_FLUSH,
42 VIRTIO_BLK_F_CONFIG_WCE,
43 VIRTIO_BLK_F_DISCARD,
44 VIRTIO_BLK_F_WRITE_ZEROES,
45 VIRTIO_F_VERSION_1,
46 VIRTIO_RING_F_INDIRECT_DESC,
47 VIRTIO_RING_F_EVENT_IDX,
48 VIRTIO_F_NOTIFY_ON_EMPTY,
49 VHOST_INVALID_FEATURE_BIT
50 };
51
52 static void vhost_user_blk_update_config(VirtIODevice *vdev, uint8_t *config)
53 {
54 VHostUserBlk *s = VHOST_USER_BLK(vdev);
55
56 memcpy(config, &s->blkcfg, sizeof(struct virtio_blk_config));
57 }
58
59 static void vhost_user_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
60 {
61 VHostUserBlk *s = VHOST_USER_BLK(vdev);
62 struct virtio_blk_config *blkcfg = (struct virtio_blk_config *)config;
63 int ret;
64
65 if (blkcfg->wce == s->blkcfg.wce) {
66 return;
67 }
68
69 ret = vhost_dev_set_config(&s->dev, &blkcfg->wce,
70 offsetof(struct virtio_blk_config, wce),
71 sizeof(blkcfg->wce),
72 VHOST_SET_CONFIG_TYPE_MASTER);
73 if (ret) {
74 error_report("set device config space failed");
75 return;
76 }
77
78 s->blkcfg.wce = blkcfg->wce;
79 }
80
81 static int vhost_user_blk_handle_config_change(struct vhost_dev *dev)
82 {
83 int ret;
84 struct virtio_blk_config blkcfg;
85 VHostUserBlk *s = VHOST_USER_BLK(dev->vdev);
86
87 ret = vhost_dev_get_config(dev, (uint8_t *)&blkcfg,
88 sizeof(struct virtio_blk_config));
89 if (ret < 0) {
90 error_report("get config space failed");
91 return -1;
92 }
93
94 /* valid for resize only */
95 if (blkcfg.capacity != s->blkcfg.capacity) {
96 s->blkcfg.capacity = blkcfg.capacity;
97 memcpy(dev->vdev->config, &s->blkcfg, sizeof(struct virtio_blk_config));
98 virtio_notify_config(dev->vdev);
99 }
100
101 return 0;
102 }
103
104 const VhostDevConfigOps blk_ops = {
105 .vhost_dev_config_notifier = vhost_user_blk_handle_config_change,
106 };
107
108 static int vhost_user_blk_start(VirtIODevice *vdev)
109 {
110 VHostUserBlk *s = VHOST_USER_BLK(vdev);
111 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
112 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
113 int i, ret;
114
115 if (!k->set_guest_notifiers) {
116 error_report("binding does not support guest notifiers");
117 return -ENOSYS;
118 }
119
120 ret = vhost_dev_enable_notifiers(&s->dev, vdev);
121 if (ret < 0) {
122 error_report("Error enabling host notifiers: %d", -ret);
123 return ret;
124 }
125
126 ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, true);
127 if (ret < 0) {
128 error_report("Error binding guest notifier: %d", -ret);
129 goto err_host_notifiers;
130 }
131
132 s->dev.acked_features = vdev->guest_features;
133
134 if (!s->inflight->addr) {
135 ret = vhost_dev_get_inflight(&s->dev, s->queue_size, s->inflight);
136 if (ret < 0) {
137 error_report("Error get inflight: %d", -ret);
138 goto err_guest_notifiers;
139 }
140 }
141
142 ret = vhost_dev_set_inflight(&s->dev, s->inflight);
143 if (ret < 0) {
144 error_report("Error set inflight: %d", -ret);
145 goto err_guest_notifiers;
146 }
147
148 ret = vhost_dev_start(&s->dev, vdev);
149 if (ret < 0) {
150 error_report("Error starting vhost: %d", -ret);
151 goto err_guest_notifiers;
152 }
153 s->started_vu = true;
154
155 /* guest_notifier_mask/pending not used yet, so just unmask
156 * everything here. virtio-pci will do the right thing by
157 * enabling/disabling irqfd.
158 */
159 for (i = 0; i < s->dev.nvqs; i++) {
160 vhost_virtqueue_mask(&s->dev, vdev, i, false);
161 }
162
163 return ret;
164
165 err_guest_notifiers:
166 k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
167 err_host_notifiers:
168 vhost_dev_disable_notifiers(&s->dev, vdev);
169 return ret;
170 }
171
172 static void vhost_user_blk_stop(VirtIODevice *vdev)
173 {
174 VHostUserBlk *s = VHOST_USER_BLK(vdev);
175 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
176 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
177 int ret;
178
179 if (!s->started_vu) {
180 return;
181 }
182 s->started_vu = false;
183
184 if (!k->set_guest_notifiers) {
185 return;
186 }
187
188 vhost_dev_stop(&s->dev, vdev);
189
190 ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
191 if (ret < 0) {
192 error_report("vhost guest notifier cleanup failed: %d", ret);
193 return;
194 }
195
196 vhost_dev_disable_notifiers(&s->dev, vdev);
197 }
198
199 static void vhost_user_blk_set_status(VirtIODevice *vdev, uint8_t status)
200 {
201 VHostUserBlk *s = VHOST_USER_BLK(vdev);
202 bool should_start = virtio_device_started(vdev, status);
203 int ret;
204
205 if (!vdev->vm_running) {
206 should_start = false;
207 }
208
209 if (!s->connected) {
210 return;
211 }
212
213 if (s->dev.started == should_start) {
214 return;
215 }
216
217 if (should_start) {
218 ret = vhost_user_blk_start(vdev);
219 if (ret < 0) {
220 error_report("vhost-user-blk: vhost start failed: %s",
221 strerror(-ret));
222 qemu_chr_fe_disconnect(&s->chardev);
223 }
224 } else {
225 vhost_user_blk_stop(vdev);
226 }
227
228 }
229
230 static uint64_t vhost_user_blk_get_features(VirtIODevice *vdev,
231 uint64_t features,
232 Error **errp)
233 {
234 VHostUserBlk *s = VHOST_USER_BLK(vdev);
235
236 /* Turn on pre-defined features */
237 virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX);
238 virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY);
239 virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY);
240 virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE);
241 virtio_add_feature(&features, VIRTIO_BLK_F_FLUSH);
242 virtio_add_feature(&features, VIRTIO_BLK_F_RO);
243 virtio_add_feature(&features, VIRTIO_BLK_F_DISCARD);
244 virtio_add_feature(&features, VIRTIO_BLK_F_WRITE_ZEROES);
245
246 if (s->config_wce) {
247 virtio_add_feature(&features, VIRTIO_BLK_F_CONFIG_WCE);
248 }
249 if (s->num_queues > 1) {
250 virtio_add_feature(&features, VIRTIO_BLK_F_MQ);
251 }
252
253 return vhost_get_features(&s->dev, user_feature_bits, features);
254 }
255
256 static void vhost_user_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
257 {
258 VHostUserBlk *s = VHOST_USER_BLK(vdev);
259 int i, ret;
260
261 if (!vdev->start_on_kick) {
262 return;
263 }
264
265 if (!s->connected) {
266 return;
267 }
268
269 if (s->dev.started) {
270 return;
271 }
272
273 /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
274 * vhost here instead of waiting for .set_status().
275 */
276 ret = vhost_user_blk_start(vdev);
277 if (ret < 0) {
278 error_report("vhost-user-blk: vhost start failed: %s",
279 strerror(-ret));
280 qemu_chr_fe_disconnect(&s->chardev);
281 return;
282 }
283
284 /* Kick right away to begin processing requests already in vring */
285 for (i = 0; i < s->dev.nvqs; i++) {
286 VirtQueue *kick_vq = virtio_get_queue(vdev, i);
287
288 if (!virtio_queue_get_desc_addr(vdev, i)) {
289 continue;
290 }
291 event_notifier_set(virtio_queue_get_host_notifier(kick_vq));
292 }
293 }
294
295 static void vhost_user_blk_reset(VirtIODevice *vdev)
296 {
297 VHostUserBlk *s = VHOST_USER_BLK(vdev);
298
299 vhost_dev_free_inflight(s->inflight);
300 }
301
302 static int vhost_user_blk_connect(DeviceState *dev)
303 {
304 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
305 VHostUserBlk *s = VHOST_USER_BLK(vdev);
306 int ret = 0;
307
308 if (s->connected) {
309 return 0;
310 }
311 s->connected = true;
312
313 s->dev.nvqs = s->num_queues;
314 s->dev.vqs = s->vhost_vqs;
315 s->dev.vq_index = 0;
316 s->dev.backend_features = 0;
317
318 vhost_dev_set_config_notifier(&s->dev, &blk_ops);
319
320 ret = vhost_dev_init(&s->dev, &s->vhost_user, VHOST_BACKEND_TYPE_USER, 0);
321 if (ret < 0) {
322 error_report("vhost-user-blk: vhost initialization failed: %s",
323 strerror(-ret));
324 return ret;
325 }
326
327 /* restore vhost state */
328 if (virtio_device_started(vdev, vdev->status)) {
329 ret = vhost_user_blk_start(vdev);
330 if (ret < 0) {
331 error_report("vhost-user-blk: vhost start failed: %s",
332 strerror(-ret));
333 return ret;
334 }
335 }
336
337 return 0;
338 }
339
340 static void vhost_user_blk_disconnect(DeviceState *dev)
341 {
342 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
343 VHostUserBlk *s = VHOST_USER_BLK(vdev);
344
345 if (!s->connected) {
346 return;
347 }
348 s->connected = false;
349
350 vhost_user_blk_stop(vdev);
351
352 vhost_dev_cleanup(&s->dev);
353 }
354
355 static void vhost_user_blk_event(void *opaque, QEMUChrEvent event);
356
357 static void vhost_user_blk_chr_closed_bh(void *opaque)
358 {
359 DeviceState *dev = opaque;
360 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
361 VHostUserBlk *s = VHOST_USER_BLK(vdev);
362
363 vhost_user_blk_disconnect(dev);
364 qemu_chr_fe_set_handlers(&s->chardev, NULL, NULL, vhost_user_blk_event,
365 NULL, opaque, NULL, true);
366 }
367
368 static void vhost_user_blk_event(void *opaque, QEMUChrEvent event)
369 {
370 DeviceState *dev = opaque;
371 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
372 VHostUserBlk *s = VHOST_USER_BLK(vdev);
373
374 switch (event) {
375 case CHR_EVENT_OPENED:
376 if (vhost_user_blk_connect(dev) < 0) {
377 qemu_chr_fe_disconnect(&s->chardev);
378 return;
379 }
380 break;
381 case CHR_EVENT_CLOSED:
382 /*
383 * A close event may happen during a read/write, but vhost
384 * code assumes the vhost_dev remains setup, so delay the
385 * stop & clear. There are two possible paths to hit this
386 * disconnect event:
387 * 1. When VM is in the RUN_STATE_PRELAUNCH state. The
388 * vhost_user_blk_device_realize() is a caller.
389 * 2. In tha main loop phase after VM start.
390 *
391 * For p2 the disconnect event will be delayed. We can't
392 * do the same for p1, because we are not running the loop
393 * at this moment. So just skip this step and perform
394 * disconnect in the caller function.
395 *
396 * TODO: maybe it is a good idea to make the same fix
397 * for other vhost-user devices.
398 */
399 if (runstate_is_running()) {
400 AioContext *ctx = qemu_get_current_aio_context();
401
402 qemu_chr_fe_set_handlers(&s->chardev, NULL, NULL, NULL, NULL,
403 NULL, NULL, false);
404 aio_bh_schedule_oneshot(ctx, vhost_user_blk_chr_closed_bh, opaque);
405 }
406
407 /*
408 * Move vhost device to the stopped state. The vhost-user device
409 * will be clean up and disconnected in BH. This can be useful in
410 * the vhost migration code. If disconnect was caught there is an
411 * option for the general vhost code to get the dev state without
412 * knowing its type (in this case vhost-user).
413 */
414 s->dev.started = false;
415 break;
416 case CHR_EVENT_BREAK:
417 case CHR_EVENT_MUX_IN:
418 case CHR_EVENT_MUX_OUT:
419 /* Ignore */
420 break;
421 }
422 }
423
424 static void vhost_user_blk_device_realize(DeviceState *dev, Error **errp)
425 {
426 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
427 VHostUserBlk *s = VHOST_USER_BLK(vdev);
428 Error *err = NULL;
429 int i, ret;
430
431 if (!s->chardev.chr) {
432 error_setg(errp, "vhost-user-blk: chardev is mandatory");
433 return;
434 }
435
436 if (s->num_queues == VHOST_USER_BLK_AUTO_NUM_QUEUES) {
437 s->num_queues = 1;
438 }
439 if (!s->num_queues || s->num_queues > VIRTIO_QUEUE_MAX) {
440 error_setg(errp, "vhost-user-blk: invalid number of IO queues");
441 return;
442 }
443
444 if (!s->queue_size) {
445 error_setg(errp, "vhost-user-blk: queue size must be non-zero");
446 return;
447 }
448
449 if (!vhost_user_init(&s->vhost_user, &s->chardev, errp)) {
450 return;
451 }
452
453 virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK,
454 sizeof(struct virtio_blk_config));
455
456 s->virtqs = g_new(VirtQueue *, s->num_queues);
457 for (i = 0; i < s->num_queues; i++) {
458 s->virtqs[i] = virtio_add_queue(vdev, s->queue_size,
459 vhost_user_blk_handle_output);
460 }
461
462 s->inflight = g_new0(struct vhost_inflight, 1);
463 s->vhost_vqs = g_new0(struct vhost_virtqueue, s->num_queues);
464 s->connected = false;
465
466 qemu_chr_fe_set_handlers(&s->chardev, NULL, NULL, vhost_user_blk_event,
467 NULL, (void *)dev, NULL, true);
468
469 reconnect:
470 if (qemu_chr_fe_wait_connected(&s->chardev, &err) < 0) {
471 error_report_err(err);
472 goto virtio_err;
473 }
474
475 /* check whether vhost_user_blk_connect() failed or not */
476 if (!s->connected) {
477 goto reconnect;
478 }
479
480 ret = vhost_dev_get_config(&s->dev, (uint8_t *)&s->blkcfg,
481 sizeof(struct virtio_blk_config));
482 if (ret < 0) {
483 error_report("vhost-user-blk: get block config failed");
484 goto reconnect;
485 }
486
487 if (s->blkcfg.num_queues != s->num_queues) {
488 s->blkcfg.num_queues = s->num_queues;
489 }
490
491 return;
492
493 virtio_err:
494 g_free(s->vhost_vqs);
495 s->vhost_vqs = NULL;
496 g_free(s->inflight);
497 s->inflight = NULL;
498 for (i = 0; i < s->num_queues; i++) {
499 virtio_delete_queue(s->virtqs[i]);
500 }
501 g_free(s->virtqs);
502 virtio_cleanup(vdev);
503 vhost_user_cleanup(&s->vhost_user);
504 }
505
506 static void vhost_user_blk_device_unrealize(DeviceState *dev)
507 {
508 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
509 VHostUserBlk *s = VHOST_USER_BLK(dev);
510 int i;
511
512 virtio_set_status(vdev, 0);
513 qemu_chr_fe_set_handlers(&s->chardev, NULL, NULL, NULL,
514 NULL, NULL, NULL, false);
515 vhost_dev_cleanup(&s->dev);
516 vhost_dev_free_inflight(s->inflight);
517 g_free(s->vhost_vqs);
518 s->vhost_vqs = NULL;
519 g_free(s->inflight);
520 s->inflight = NULL;
521
522 for (i = 0; i < s->num_queues; i++) {
523 virtio_delete_queue(s->virtqs[i]);
524 }
525 g_free(s->virtqs);
526 virtio_cleanup(vdev);
527 vhost_user_cleanup(&s->vhost_user);
528 }
529
530 static void vhost_user_blk_instance_init(Object *obj)
531 {
532 VHostUserBlk *s = VHOST_USER_BLK(obj);
533
534 device_add_bootindex_property(obj, &s->bootindex, "bootindex",
535 "/disk@0,0", DEVICE(obj));
536 }
537
538 static const VMStateDescription vmstate_vhost_user_blk = {
539 .name = "vhost-user-blk",
540 .minimum_version_id = 1,
541 .version_id = 1,
542 .fields = (VMStateField[]) {
543 VMSTATE_VIRTIO_DEVICE,
544 VMSTATE_END_OF_LIST()
545 },
546 };
547
548 static Property vhost_user_blk_properties[] = {
549 DEFINE_PROP_CHR("chardev", VHostUserBlk, chardev),
550 DEFINE_PROP_UINT16("num-queues", VHostUserBlk, num_queues,
551 VHOST_USER_BLK_AUTO_NUM_QUEUES),
552 DEFINE_PROP_UINT32("queue-size", VHostUserBlk, queue_size, 128),
553 DEFINE_PROP_BIT("config-wce", VHostUserBlk, config_wce, 0, true),
554 DEFINE_PROP_END_OF_LIST(),
555 };
556
557 static void vhost_user_blk_class_init(ObjectClass *klass, void *data)
558 {
559 DeviceClass *dc = DEVICE_CLASS(klass);
560 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
561
562 device_class_set_props(dc, vhost_user_blk_properties);
563 dc->vmsd = &vmstate_vhost_user_blk;
564 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
565 vdc->realize = vhost_user_blk_device_realize;
566 vdc->unrealize = vhost_user_blk_device_unrealize;
567 vdc->get_config = vhost_user_blk_update_config;
568 vdc->set_config = vhost_user_blk_set_config;
569 vdc->get_features = vhost_user_blk_get_features;
570 vdc->set_status = vhost_user_blk_set_status;
571 vdc->reset = vhost_user_blk_reset;
572 }
573
574 static const TypeInfo vhost_user_blk_info = {
575 .name = TYPE_VHOST_USER_BLK,
576 .parent = TYPE_VIRTIO_DEVICE,
577 .instance_size = sizeof(VHostUserBlk),
578 .instance_init = vhost_user_blk_instance_init,
579 .class_init = vhost_user_blk_class_init,
580 };
581
582 static void virtio_register_types(void)
583 {
584 type_register_static(&vhost_user_blk_info);
585 }
586
587 type_init(virtio_register_types)