xref: /openbmc/qemu/hw/block/vhost-user-blk.c (revision 65a117da) 
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 "qom/object.h"
24 #include "hw/qdev-core.h"
25 #include "hw/qdev-properties.h"
26 #include "hw/virtio/vhost.h"
27 #include "hw/virtio/vhost-user-blk.h"
28 #include "hw/virtio/virtio.h"
29 #include "hw/virtio/virtio-bus.h"
30 #include "hw/virtio/virtio-access.h"
31 #include "sysemu/sysemu.h"
32 #include "sysemu/runstate.h"
33 
34 static const int user_feature_bits[] = {
35     VIRTIO_BLK_F_SIZE_MAX,
36     VIRTIO_BLK_F_SEG_MAX,
37     VIRTIO_BLK_F_GEOMETRY,
38     VIRTIO_BLK_F_BLK_SIZE,
39     VIRTIO_BLK_F_TOPOLOGY,
40     VIRTIO_BLK_F_MQ,
41     VIRTIO_BLK_F_RO,
42     VIRTIO_BLK_F_FLUSH,
43     VIRTIO_BLK_F_CONFIG_WCE,
44     VIRTIO_BLK_F_DISCARD,
45     VIRTIO_BLK_F_WRITE_ZEROES,
46     VIRTIO_F_VERSION_1,
47     VIRTIO_RING_F_INDIRECT_DESC,
48     VIRTIO_RING_F_EVENT_IDX,
49     VIRTIO_F_NOTIFY_ON_EMPTY,
50     VHOST_INVALID_FEATURE_BIT
51 };
52 
53 static void vhost_user_blk_update_config(VirtIODevice *vdev, uint8_t *config)
54 {
55     VHostUserBlk *s = VHOST_USER_BLK(vdev);
56 
57     memcpy(config, &s->blkcfg, sizeof(struct virtio_blk_config));
58 }
59 
60 static void vhost_user_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
61 {
62     VHostUserBlk *s = VHOST_USER_BLK(vdev);
63     struct virtio_blk_config *blkcfg = (struct virtio_blk_config *)config;
64     int ret;
65 
66     if (blkcfg->wce == s->blkcfg.wce) {
67         return;
68     }
69 
70     ret = vhost_dev_set_config(&s->dev, &blkcfg->wce,
71                                offsetof(struct virtio_blk_config, wce),
72                                sizeof(blkcfg->wce),
73                                VHOST_SET_CONFIG_TYPE_MASTER);
74     if (ret) {
75         error_report("set device config space failed");
76         return;
77     }
78 
79     s->blkcfg.wce = blkcfg->wce;
80 }
81 
82 static int vhost_user_blk_handle_config_change(struct vhost_dev *dev)
83 {
84     int ret;
85     struct virtio_blk_config blkcfg;
86     VHostUserBlk *s = VHOST_USER_BLK(dev->vdev);
87 
88     ret = vhost_dev_get_config(dev, (uint8_t *)&blkcfg,
89                                sizeof(struct virtio_blk_config));
90     if (ret < 0) {
91         error_report("get config space failed");
92         return -1;
93     }
94 
95     /* valid for resize only */
96     if (blkcfg.capacity != s->blkcfg.capacity) {
97         s->blkcfg.capacity = blkcfg.capacity;
98         memcpy(dev->vdev->config, &s->blkcfg, sizeof(struct virtio_blk_config));
99         virtio_notify_config(dev->vdev);
100     }
101 
102     return 0;
103 }
104 
105 const VhostDevConfigOps blk_ops = {
106     .vhost_dev_config_notifier = vhost_user_blk_handle_config_change,
107 };
108 
109 static int vhost_user_blk_start(VirtIODevice *vdev)
110 {
111     VHostUserBlk *s = VHOST_USER_BLK(vdev);
112     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
113     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
114     int i, ret;
115 
116     if (!k->set_guest_notifiers) {
117         error_report("binding does not support guest notifiers");
118         return -ENOSYS;
119     }
120 
121     ret = vhost_dev_enable_notifiers(&s->dev, vdev);
122     if (ret < 0) {
123         error_report("Error enabling host notifiers: %d", -ret);
124         return ret;
125     }
126 
127     ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, true);
128     if (ret < 0) {
129         error_report("Error binding guest notifier: %d", -ret);
130         goto err_host_notifiers;
131     }
132 
133     s->dev.acked_features = vdev->guest_features;
134 
135     if (!s->inflight->addr) {
136         ret = vhost_dev_get_inflight(&s->dev, s->queue_size, s->inflight);
137         if (ret < 0) {
138             error_report("Error get inflight: %d", -ret);
139             goto err_guest_notifiers;
140         }
141     }
142 
143     ret = vhost_dev_set_inflight(&s->dev, s->inflight);
144     if (ret < 0) {
145         error_report("Error set inflight: %d", -ret);
146         goto err_guest_notifiers;
147     }
148 
149     ret = vhost_dev_start(&s->dev, vdev);
150     if (ret < 0) {
151         error_report("Error starting vhost: %d", -ret);
152         goto err_guest_notifiers;
153     }
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 (!k->set_guest_notifiers) {
180         return;
181     }
182 
183     vhost_dev_stop(&s->dev, vdev);
184 
185     ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
186     if (ret < 0) {
187         error_report("vhost guest notifier cleanup failed: %d", ret);
188         return;
189     }
190 
191     vhost_dev_disable_notifiers(&s->dev, vdev);
192 }
193 
194 static void vhost_user_blk_set_status(VirtIODevice *vdev, uint8_t status)
195 {
196     VHostUserBlk *s = VHOST_USER_BLK(vdev);
197     bool should_start = virtio_device_started(vdev, status);
198     int ret;
199 
200     if (!vdev->vm_running) {
201         should_start = false;
202     }
203 
204     if (!s->connected) {
205         return;
206     }
207 
208     if (s->dev.started == should_start) {
209         return;
210     }
211 
212     if (should_start) {
213         ret = vhost_user_blk_start(vdev);
214         if (ret < 0) {
215             error_report("vhost-user-blk: vhost start failed: %s",
216                          strerror(-ret));
217             qemu_chr_fe_disconnect(&s->chardev);
218         }
219     } else {
220         vhost_user_blk_stop(vdev);
221     }
222 
223 }
224 
225 static uint64_t vhost_user_blk_get_features(VirtIODevice *vdev,
226                                             uint64_t features,
227                                             Error **errp)
228 {
229     VHostUserBlk *s = VHOST_USER_BLK(vdev);
230 
231     /* Turn on pre-defined features */
232     virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX);
233     virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY);
234     virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY);
235     virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE);
236     virtio_add_feature(&features, VIRTIO_BLK_F_FLUSH);
237     virtio_add_feature(&features, VIRTIO_BLK_F_RO);
238     virtio_add_feature(&features, VIRTIO_BLK_F_DISCARD);
239     virtio_add_feature(&features, VIRTIO_BLK_F_WRITE_ZEROES);
240 
241     if (s->config_wce) {
242         virtio_add_feature(&features, VIRTIO_BLK_F_CONFIG_WCE);
243     }
244     if (s->num_queues > 1) {
245         virtio_add_feature(&features, VIRTIO_BLK_F_MQ);
246     }
247 
248     return vhost_get_features(&s->dev, user_feature_bits, features);
249 }
250 
251 static void vhost_user_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
252 {
253     VHostUserBlk *s = VHOST_USER_BLK(vdev);
254     int i, ret;
255 
256     if (!vdev->start_on_kick) {
257         return;
258     }
259 
260     if (!s->connected) {
261         return;
262     }
263 
264     if (s->dev.started) {
265         return;
266     }
267 
268     /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
269      * vhost here instead of waiting for .set_status().
270      */
271     ret = vhost_user_blk_start(vdev);
272     if (ret < 0) {
273         error_report("vhost-user-blk: vhost start failed: %s",
274                      strerror(-ret));
275         qemu_chr_fe_disconnect(&s->chardev);
276         return;
277     }
278 
279     /* Kick right away to begin processing requests already in vring */
280     for (i = 0; i < s->dev.nvqs; i++) {
281         VirtQueue *kick_vq = virtio_get_queue(vdev, i);
282 
283         if (!virtio_queue_get_desc_addr(vdev, i)) {
284             continue;
285         }
286         event_notifier_set(virtio_queue_get_host_notifier(kick_vq));
287     }
288 }
289 
290 static void vhost_user_blk_reset(VirtIODevice *vdev)
291 {
292     VHostUserBlk *s = VHOST_USER_BLK(vdev);
293 
294     vhost_dev_free_inflight(s->inflight);
295 }
296 
297 static int vhost_user_blk_connect(DeviceState *dev)
298 {
299     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
300     VHostUserBlk *s = VHOST_USER_BLK(vdev);
301     int ret = 0;
302 
303     if (s->connected) {
304         return 0;
305     }
306     s->connected = true;
307 
308     s->dev.nvqs = s->num_queues;
309     s->dev.vqs = s->vhost_vqs;
310     s->dev.vq_index = 0;
311     s->dev.backend_features = 0;
312 
313     vhost_dev_set_config_notifier(&s->dev, &blk_ops);
314 
315     ret = vhost_dev_init(&s->dev, &s->vhost_user, VHOST_BACKEND_TYPE_USER, 0);
316     if (ret < 0) {
317         error_report("vhost-user-blk: vhost initialization failed: %s",
318                      strerror(-ret));
319         return ret;
320     }
321 
322     /* restore vhost state */
323     if (virtio_device_started(vdev, vdev->status)) {
324         ret = vhost_user_blk_start(vdev);
325         if (ret < 0) {
326             error_report("vhost-user-blk: vhost start failed: %s",
327                          strerror(-ret));
328             return ret;
329         }
330     }
331 
332     return 0;
333 }
334 
335 static void vhost_user_blk_disconnect(DeviceState *dev)
336 {
337     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
338     VHostUserBlk *s = VHOST_USER_BLK(vdev);
339 
340     if (!s->connected) {
341         return;
342     }
343     s->connected = false;
344 
345     if (s->dev.started) {
346         vhost_user_blk_stop(vdev);
347     }
348 
349     vhost_dev_cleanup(&s->dev);
350 }
351 
352 static void vhost_user_blk_event(void *opaque, QEMUChrEvent event)
353 {
354     DeviceState *dev = opaque;
355     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
356     VHostUserBlk *s = VHOST_USER_BLK(vdev);
357 
358     switch (event) {
359     case CHR_EVENT_OPENED:
360         if (vhost_user_blk_connect(dev) < 0) {
361             qemu_chr_fe_disconnect(&s->chardev);
362             return;
363         }
364         break;
365     case CHR_EVENT_CLOSED:
366         vhost_user_blk_disconnect(dev);
367         break;
368     case CHR_EVENT_BREAK:
369     case CHR_EVENT_MUX_IN:
370     case CHR_EVENT_MUX_OUT:
371         /* Ignore */
372         break;
373     }
374 }
375 
376 static void vhost_user_blk_device_realize(DeviceState *dev, Error **errp)
377 {
378     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
379     VHostUserBlk *s = VHOST_USER_BLK(vdev);
380     Error *err = NULL;
381     int i, ret;
382 
383     if (!s->chardev.chr) {
384         error_setg(errp, "vhost-user-blk: chardev is mandatory");
385         return;
386     }
387 
388     if (!s->num_queues || s->num_queues > VIRTIO_QUEUE_MAX) {
389         error_setg(errp, "vhost-user-blk: invalid number of IO queues");
390         return;
391     }
392 
393     if (!s->queue_size) {
394         error_setg(errp, "vhost-user-blk: queue size must be non-zero");
395         return;
396     }
397 
398     if (!vhost_user_init(&s->vhost_user, &s->chardev, errp)) {
399         return;
400     }
401 
402     virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK,
403                 sizeof(struct virtio_blk_config));
404 
405     s->virtqs = g_new(VirtQueue *, s->num_queues);
406     for (i = 0; i < s->num_queues; i++) {
407         s->virtqs[i] = virtio_add_queue(vdev, s->queue_size,
408                                         vhost_user_blk_handle_output);
409     }
410 
411     s->inflight = g_new0(struct vhost_inflight, 1);
412     s->vhost_vqs = g_new0(struct vhost_virtqueue, s->num_queues);
413     s->connected = false;
414 
415     qemu_chr_fe_set_handlers(&s->chardev,  NULL, NULL, vhost_user_blk_event,
416                              NULL, (void *)dev, NULL, true);
417 
418 reconnect:
419     if (qemu_chr_fe_wait_connected(&s->chardev, &err) < 0) {
420         error_report_err(err);
421         goto virtio_err;
422     }
423 
424     /* check whether vhost_user_blk_connect() failed or not */
425     if (!s->connected) {
426         goto reconnect;
427     }
428 
429     ret = vhost_dev_get_config(&s->dev, (uint8_t *)&s->blkcfg,
430                                sizeof(struct virtio_blk_config));
431     if (ret < 0) {
432         error_report("vhost-user-blk: get block config failed");
433         goto reconnect;
434     }
435 
436     if (s->blkcfg.num_queues != s->num_queues) {
437         s->blkcfg.num_queues = s->num_queues;
438     }
439 
440     return;
441 
442 virtio_err:
443     g_free(s->vhost_vqs);
444     s->vhost_vqs = NULL;
445     g_free(s->inflight);
446     s->inflight = NULL;
447     for (i = 0; i < s->num_queues; i++) {
448         virtio_delete_queue(s->virtqs[i]);
449     }
450     g_free(s->virtqs);
451     virtio_cleanup(vdev);
452     vhost_user_cleanup(&s->vhost_user);
453 }
454 
455 static void vhost_user_blk_device_unrealize(DeviceState *dev)
456 {
457     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
458     VHostUserBlk *s = VHOST_USER_BLK(dev);
459     int i;
460 
461     virtio_set_status(vdev, 0);
462     qemu_chr_fe_set_handlers(&s->chardev,  NULL, NULL, NULL,
463                              NULL, NULL, NULL, false);
464     vhost_dev_cleanup(&s->dev);
465     vhost_dev_free_inflight(s->inflight);
466     g_free(s->vhost_vqs);
467     s->vhost_vqs = NULL;
468     g_free(s->inflight);
469     s->inflight = NULL;
470 
471     for (i = 0; i < s->num_queues; i++) {
472         virtio_delete_queue(s->virtqs[i]);
473     }
474     g_free(s->virtqs);
475     virtio_cleanup(vdev);
476     vhost_user_cleanup(&s->vhost_user);
477 }
478 
479 static void vhost_user_blk_instance_init(Object *obj)
480 {
481     VHostUserBlk *s = VHOST_USER_BLK(obj);
482 
483     device_add_bootindex_property(obj, &s->bootindex, "bootindex",
484                                   "/disk@0,0", DEVICE(obj));
485 }
486 
487 static const VMStateDescription vmstate_vhost_user_blk = {
488     .name = "vhost-user-blk",
489     .minimum_version_id = 1,
490     .version_id = 1,
491     .fields = (VMStateField[]) {
492         VMSTATE_VIRTIO_DEVICE,
493         VMSTATE_END_OF_LIST()
494     },
495 };
496 
497 static Property vhost_user_blk_properties[] = {
498     DEFINE_PROP_CHR("chardev", VHostUserBlk, chardev),
499     DEFINE_PROP_UINT16("num-queues", VHostUserBlk, num_queues, 1),
500     DEFINE_PROP_UINT32("queue-size", VHostUserBlk, queue_size, 128),
501     DEFINE_PROP_BIT("config-wce", VHostUserBlk, config_wce, 0, true),
502     DEFINE_PROP_END_OF_LIST(),
503 };
504 
505 static void vhost_user_blk_class_init(ObjectClass *klass, void *data)
506 {
507     DeviceClass *dc = DEVICE_CLASS(klass);
508     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
509 
510     device_class_set_props(dc, vhost_user_blk_properties);
511     dc->vmsd = &vmstate_vhost_user_blk;
512     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
513     vdc->realize = vhost_user_blk_device_realize;
514     vdc->unrealize = vhost_user_blk_device_unrealize;
515     vdc->get_config = vhost_user_blk_update_config;
516     vdc->set_config = vhost_user_blk_set_config;
517     vdc->get_features = vhost_user_blk_get_features;
518     vdc->set_status = vhost_user_blk_set_status;
519     vdc->reset = vhost_user_blk_reset;
520 }
521 
522 static const TypeInfo vhost_user_blk_info = {
523     .name = TYPE_VHOST_USER_BLK,
524     .parent = TYPE_VIRTIO_DEVICE,
525     .instance_size = sizeof(VHostUserBlk),
526     .instance_init = vhost_user_blk_instance_init,
527     .class_init = vhost_user_blk_class_init,
528 };
529 
530 static void virtio_register_types(void)
531 {
532     type_register_static(&vhost_user_blk_info);
533 }
534 
535 type_init(virtio_register_types)
536