xref: /openbmc/qemu/hw/block/xen-block.c (revision 6832189f)
1 /*
2  * Copyright (c) 2018  Citrix Systems Inc.
3  *
4  * This work is licensed under the terms of the GNU GPL, version 2 or later.
5  * See the COPYING file in the top-level directory.
6  */
7 
8 #include "qemu/osdep.h"
9 #include "qemu/cutils.h"
10 #include "qemu/main-loop.h"
11 #include "qemu/module.h"
12 #include "qemu/option.h"
13 #include "qapi/error.h"
14 #include "qapi/qapi-commands-block-core.h"
15 #include "qapi/qapi-commands-qom.h"
16 #include "qapi/qapi-visit-block-core.h"
17 #include "qapi/qobject-input-visitor.h"
18 #include "qapi/visitor.h"
19 #include "qapi/qmp/qdict.h"
20 #include "qapi/qmp/qstring.h"
21 #include "qom/object_interfaces.h"
22 #include "hw/xen/xen_common.h"
23 #include "hw/block/xen_blkif.h"
24 #include "hw/qdev-properties.h"
25 #include "hw/xen/xen-block.h"
26 #include "hw/xen/xen-backend.h"
27 #include "sysemu/blockdev.h"
28 #include "sysemu/block-backend.h"
29 #include "sysemu/iothread.h"
30 #include "dataplane/xen-block.h"
31 #include "trace.h"
32 
33 static char *xen_block_get_name(XenDevice *xendev, Error **errp)
34 {
35     XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
36     XenBlockVdev *vdev = &blockdev->props.vdev;
37 
38     return g_strdup_printf("%lu", vdev->number);
39 }
40 
41 static void xen_block_disconnect(XenDevice *xendev, Error **errp)
42 {
43     XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
44     const char *type = object_get_typename(OBJECT(blockdev));
45     XenBlockVdev *vdev = &blockdev->props.vdev;
46 
47     trace_xen_block_disconnect(type, vdev->disk, vdev->partition);
48 
49     xen_block_dataplane_stop(blockdev->dataplane);
50 }
51 
52 static void xen_block_connect(XenDevice *xendev, Error **errp)
53 {
54     XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
55     const char *type = object_get_typename(OBJECT(blockdev));
56     XenBlockVdev *vdev = &blockdev->props.vdev;
57     BlockConf *conf = &blockdev->props.conf;
58     unsigned int feature_large_sector_size;
59     unsigned int order, nr_ring_ref, *ring_ref, event_channel, protocol;
60     char *str;
61 
62     trace_xen_block_connect(type, vdev->disk, vdev->partition);
63 
64     if (xen_device_frontend_scanf(xendev, "feature-large-sector-size", "%u",
65                                   &feature_large_sector_size) != 1) {
66         feature_large_sector_size = 0;
67     }
68 
69     if (feature_large_sector_size != 1 &&
70         conf->logical_block_size != XEN_BLKIF_SECTOR_SIZE) {
71         error_setg(errp, "logical_block_size != %u not supported by frontend",
72                    XEN_BLKIF_SECTOR_SIZE);
73         return;
74     }
75 
76     if (xen_device_frontend_scanf(xendev, "ring-page-order", "%u",
77                                   &order) != 1) {
78         nr_ring_ref = 1;
79         ring_ref = g_new(unsigned int, nr_ring_ref);
80 
81         if (xen_device_frontend_scanf(xendev, "ring-ref", "%u",
82                                       &ring_ref[0]) != 1) {
83             error_setg(errp, "failed to read ring-ref");
84             g_free(ring_ref);
85             return;
86         }
87     } else if (order <= blockdev->props.max_ring_page_order) {
88         unsigned int i;
89 
90         nr_ring_ref = 1 << order;
91         ring_ref = g_new(unsigned int, nr_ring_ref);
92 
93         for (i = 0; i < nr_ring_ref; i++) {
94             const char *key = g_strdup_printf("ring-ref%u", i);
95 
96             if (xen_device_frontend_scanf(xendev, key, "%u",
97                                           &ring_ref[i]) != 1) {
98                 error_setg(errp, "failed to read %s", key);
99                 g_free((gpointer)key);
100                 g_free(ring_ref);
101                 return;
102             }
103 
104             g_free((gpointer)key);
105         }
106     } else {
107         error_setg(errp, "invalid ring-page-order (%d)", order);
108         return;
109     }
110 
111     if (xen_device_frontend_scanf(xendev, "event-channel", "%u",
112                                   &event_channel) != 1) {
113         error_setg(errp, "failed to read event-channel");
114         g_free(ring_ref);
115         return;
116     }
117 
118     if (xen_device_frontend_scanf(xendev, "protocol", "%ms",
119                                   &str) != 1) {
120         protocol = BLKIF_PROTOCOL_NATIVE;
121     } else {
122         if (strcmp(str, XEN_IO_PROTO_ABI_X86_32) == 0) {
123             protocol = BLKIF_PROTOCOL_X86_32;
124         } else if (strcmp(str, XEN_IO_PROTO_ABI_X86_64) == 0) {
125             protocol = BLKIF_PROTOCOL_X86_64;
126         } else {
127             protocol = BLKIF_PROTOCOL_NATIVE;
128         }
129 
130         free(str);
131     }
132 
133     xen_block_dataplane_start(blockdev->dataplane, ring_ref, nr_ring_ref,
134                               event_channel, protocol, errp);
135 
136     g_free(ring_ref);
137 }
138 
139 static void xen_block_unrealize(XenDevice *xendev)
140 {
141     XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
142     XenBlockDeviceClass *blockdev_class =
143         XEN_BLOCK_DEVICE_GET_CLASS(xendev);
144     const char *type = object_get_typename(OBJECT(blockdev));
145     XenBlockVdev *vdev = &blockdev->props.vdev;
146 
147     if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) {
148         return;
149     }
150 
151     trace_xen_block_unrealize(type, vdev->disk, vdev->partition);
152 
153     /* Disconnect from the frontend in case this has not already happened */
154     xen_block_disconnect(xendev, NULL);
155 
156     xen_block_dataplane_destroy(blockdev->dataplane);
157     blockdev->dataplane = NULL;
158 
159     if (blockdev_class->unrealize) {
160         blockdev_class->unrealize(blockdev);
161     }
162 }
163 
164 static void xen_block_set_size(XenBlockDevice *blockdev)
165 {
166     const char *type = object_get_typename(OBJECT(blockdev));
167     XenBlockVdev *vdev = &blockdev->props.vdev;
168     BlockConf *conf = &blockdev->props.conf;
169     int64_t sectors = blk_getlength(conf->blk) / conf->logical_block_size;
170     XenDevice *xendev = XEN_DEVICE(blockdev);
171 
172     trace_xen_block_size(type, vdev->disk, vdev->partition, sectors);
173 
174     xen_device_backend_printf(xendev, "sectors", "%"PRIi64, sectors);
175 }
176 
177 static void xen_block_resize_cb(void *opaque)
178 {
179     XenBlockDevice *blockdev = opaque;
180     XenDevice *xendev = XEN_DEVICE(blockdev);
181     enum xenbus_state state = xen_device_backend_get_state(xendev);
182 
183     xen_block_set_size(blockdev);
184 
185     /*
186      * Mimic the behaviour of Linux xen-blkback and re-write the state
187      * to trigger the frontend watch.
188      */
189     xen_device_backend_printf(xendev, "state", "%u", state);
190 }
191 
192 static const BlockDevOps xen_block_dev_ops = {
193     .resize_cb = xen_block_resize_cb,
194 };
195 
196 static void xen_block_realize(XenDevice *xendev, Error **errp)
197 {
198     ERRP_GUARD();
199     XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
200     XenBlockDeviceClass *blockdev_class =
201         XEN_BLOCK_DEVICE_GET_CLASS(xendev);
202     const char *type = object_get_typename(OBJECT(blockdev));
203     XenBlockVdev *vdev = &blockdev->props.vdev;
204     BlockConf *conf = &blockdev->props.conf;
205     BlockBackend *blk = conf->blk;
206 
207     if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) {
208         error_setg(errp, "vdev property not set");
209         return;
210     }
211 
212     trace_xen_block_realize(type, vdev->disk, vdev->partition);
213 
214     if (blockdev_class->realize) {
215         blockdev_class->realize(blockdev, errp);
216         if (*errp) {
217             return;
218         }
219     }
220 
221     /*
222      * The blkif protocol does not deal with removable media, so it must
223      * always be present, even for CDRom devices.
224      */
225     assert(blk);
226     if (!blk_is_inserted(blk)) {
227         error_setg(errp, "device needs media, but drive is empty");
228         return;
229     }
230 
231     if (!blkconf_apply_backend_options(conf, blockdev->info & VDISK_READONLY,
232                                        true, errp)) {
233         return;
234     }
235 
236     if (!(blockdev->info & VDISK_CDROM) &&
237         !blkconf_geometry(conf, NULL, 65535, 255, 255, errp)) {
238         return;
239     }
240 
241     if (!blkconf_blocksizes(conf, errp)) {
242         return;
243     }
244 
245     blk_set_dev_ops(blk, &xen_block_dev_ops, blockdev);
246 
247     if (conf->discard_granularity == -1) {
248         conf->discard_granularity = conf->physical_block_size;
249     }
250 
251     if (blk_get_flags(blk) & BDRV_O_UNMAP) {
252         xen_device_backend_printf(xendev, "feature-discard", "%u", 1);
253         xen_device_backend_printf(xendev, "discard-granularity", "%u",
254                                   conf->discard_granularity);
255         xen_device_backend_printf(xendev, "discard-alignment", "%u", 0);
256     }
257 
258     xen_device_backend_printf(xendev, "feature-flush-cache", "%u", 1);
259     xen_device_backend_printf(xendev, "max-ring-page-order", "%u",
260                               blockdev->props.max_ring_page_order);
261     xen_device_backend_printf(xendev, "info", "%u", blockdev->info);
262 
263     xen_device_frontend_printf(xendev, "virtual-device", "%lu",
264                                vdev->number);
265     xen_device_frontend_printf(xendev, "device-type", "%s",
266                                blockdev->device_type);
267 
268     xen_device_backend_printf(xendev, "sector-size", "%u",
269                               conf->logical_block_size);
270 
271     xen_block_set_size(blockdev);
272 
273     blockdev->dataplane =
274         xen_block_dataplane_create(xendev, blk, conf->logical_block_size,
275                                    blockdev->props.iothread);
276 }
277 
278 static void xen_block_frontend_changed(XenDevice *xendev,
279                                        enum xenbus_state frontend_state,
280                                        Error **errp)
281 {
282     ERRP_GUARD();
283     enum xenbus_state backend_state = xen_device_backend_get_state(xendev);
284 
285     switch (frontend_state) {
286     case XenbusStateInitialised:
287     case XenbusStateConnected:
288         if (backend_state == XenbusStateConnected) {
289             break;
290         }
291 
292         xen_block_disconnect(xendev, errp);
293         if (*errp) {
294             break;
295         }
296 
297         xen_block_connect(xendev, errp);
298         if (*errp) {
299             break;
300         }
301 
302         xen_device_backend_set_state(xendev, XenbusStateConnected);
303         break;
304 
305     case XenbusStateClosing:
306         xen_device_backend_set_state(xendev, XenbusStateClosing);
307         break;
308 
309     case XenbusStateClosed:
310     case XenbusStateUnknown:
311         xen_block_disconnect(xendev, errp);
312         if (*errp) {
313             break;
314         }
315 
316         xen_device_backend_set_state(xendev, XenbusStateClosed);
317         break;
318 
319     default:
320         break;
321     }
322 }
323 
324 static char *disk_to_vbd_name(unsigned int disk)
325 {
326     char *name, *prefix = (disk >= 26) ?
327         disk_to_vbd_name((disk / 26) - 1) : g_strdup("");
328 
329     name = g_strdup_printf("%s%c", prefix, 'a' + disk % 26);
330     g_free(prefix);
331 
332     return name;
333 }
334 
335 static void xen_block_get_vdev(Object *obj, Visitor *v, const char *name,
336                                void *opaque, Error **errp)
337 {
338     Property *prop = opaque;
339     XenBlockVdev *vdev = object_field_prop_ptr(obj, prop);
340     char *str;
341 
342     switch (vdev->type) {
343     case XEN_BLOCK_VDEV_TYPE_DP:
344         str = g_strdup_printf("d%lup%lu", vdev->disk, vdev->partition);
345         break;
346 
347     case XEN_BLOCK_VDEV_TYPE_XVD:
348     case XEN_BLOCK_VDEV_TYPE_HD:
349     case XEN_BLOCK_VDEV_TYPE_SD: {
350         char *name = disk_to_vbd_name(vdev->disk);
351 
352         str = g_strdup_printf("%s%s%lu",
353                               (vdev->type == XEN_BLOCK_VDEV_TYPE_XVD) ?
354                               "xvd" :
355                               (vdev->type == XEN_BLOCK_VDEV_TYPE_HD) ?
356                               "hd" :
357                               "sd",
358                               name, vdev->partition);
359         g_free(name);
360         break;
361     }
362     default:
363         error_setg(errp, "invalid vdev type");
364         return;
365     }
366 
367     visit_type_str(v, name, &str, errp);
368     g_free(str);
369 }
370 
371 static int vbd_name_to_disk(const char *name, const char **endp,
372                             unsigned long *disk)
373 {
374     unsigned int n = 0;
375 
376     while (*name != '\0') {
377         if (!g_ascii_isalpha(*name) || !g_ascii_islower(*name)) {
378             break;
379         }
380 
381         n *= 26;
382         n += *name++ - 'a' + 1;
383     }
384     *endp = name;
385 
386     if (!n) {
387         return -1;
388     }
389 
390     *disk = n - 1;
391 
392     return 0;
393 }
394 
395 static void xen_block_set_vdev(Object *obj, Visitor *v, const char *name,
396                                void *opaque, Error **errp)
397 {
398     Property *prop = opaque;
399     XenBlockVdev *vdev = object_field_prop_ptr(obj, prop);
400     char *str, *p;
401     const char *end;
402 
403     if (!visit_type_str(v, name, &str, errp)) {
404         return;
405     }
406 
407     p = strchr(str, 'd');
408     if (!p) {
409         goto invalid;
410     }
411 
412     *p++ = '\0';
413     if (*str == '\0') {
414         vdev->type = XEN_BLOCK_VDEV_TYPE_DP;
415     } else if (strcmp(str, "xv") == 0) {
416         vdev->type = XEN_BLOCK_VDEV_TYPE_XVD;
417     } else if (strcmp(str, "h") == 0) {
418         vdev->type = XEN_BLOCK_VDEV_TYPE_HD;
419     } else if (strcmp(str, "s") == 0) {
420         vdev->type = XEN_BLOCK_VDEV_TYPE_SD;
421     } else {
422         goto invalid;
423     }
424 
425     if (vdev->type == XEN_BLOCK_VDEV_TYPE_DP) {
426         if (qemu_strtoul(p, &end, 10, &vdev->disk)) {
427             goto invalid;
428         }
429 
430         if (*end == 'p') {
431             if (*(++end) == '\0') {
432                 goto invalid;
433             }
434         }
435     } else {
436         if (vbd_name_to_disk(p, &end, &vdev->disk)) {
437             goto invalid;
438         }
439     }
440 
441     if (*end != '\0') {
442         p = (char *)end;
443 
444         if (qemu_strtoul(p, &end, 10, &vdev->partition)) {
445             goto invalid;
446         }
447 
448         if (*end != '\0') {
449             goto invalid;
450         }
451     } else {
452         vdev->partition = 0;
453     }
454 
455     switch (vdev->type) {
456     case XEN_BLOCK_VDEV_TYPE_DP:
457     case XEN_BLOCK_VDEV_TYPE_XVD:
458         if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) {
459             vdev->number = (202 << 8) | (vdev->disk << 4) |
460                 vdev->partition;
461         } else if (vdev->disk < (1 << 20) && vdev->partition < (1 << 8)) {
462             vdev->number = (1 << 28) | (vdev->disk << 8) |
463                 vdev->partition;
464         } else {
465             goto invalid;
466         }
467         break;
468 
469     case XEN_BLOCK_VDEV_TYPE_HD:
470         if ((vdev->disk == 0 || vdev->disk == 1) &&
471             vdev->partition < (1 << 6)) {
472             vdev->number = (3 << 8) | (vdev->disk << 6) | vdev->partition;
473         } else if ((vdev->disk == 2 || vdev->disk == 3) &&
474                    vdev->partition < (1 << 6)) {
475             vdev->number = (22 << 8) | ((vdev->disk - 2) << 6) |
476                 vdev->partition;
477         } else {
478             goto invalid;
479         }
480         break;
481 
482     case XEN_BLOCK_VDEV_TYPE_SD:
483         if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) {
484             vdev->number = (8 << 8) | (vdev->disk << 4) | vdev->partition;
485         } else {
486             goto invalid;
487         }
488         break;
489 
490     default:
491         goto invalid;
492     }
493 
494     g_free(str);
495     return;
496 
497 invalid:
498     error_setg(errp, "invalid virtual disk specifier");
499 
500     vdev->type = XEN_BLOCK_VDEV_TYPE_INVALID;
501     g_free(str);
502 }
503 
504 /*
505  * This property deals with 'vdev' names adhering to the Xen VBD naming
506  * scheme described in:
507  *
508  * https://xenbits.xen.org/docs/unstable/man/xen-vbd-interface.7.html
509  */
510 const PropertyInfo xen_block_prop_vdev = {
511     .name  = "str",
512     .description = "Virtual Disk specifier: d*p*/xvd*/hd*/sd*",
513     .get = xen_block_get_vdev,
514     .set = xen_block_set_vdev,
515 };
516 
517 static Property xen_block_props[] = {
518     DEFINE_PROP("vdev", XenBlockDevice, props.vdev,
519                 xen_block_prop_vdev, XenBlockVdev),
520     DEFINE_BLOCK_PROPERTIES(XenBlockDevice, props.conf),
521     DEFINE_PROP_UINT32("max-ring-page-order", XenBlockDevice,
522                        props.max_ring_page_order, 4),
523     DEFINE_PROP_LINK("iothread", XenBlockDevice, props.iothread,
524                      TYPE_IOTHREAD, IOThread *),
525     DEFINE_PROP_END_OF_LIST()
526 };
527 
528 static void xen_block_class_init(ObjectClass *class, void *data)
529 {
530     DeviceClass *dev_class = DEVICE_CLASS(class);
531     XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class);
532 
533     xendev_class->backend = "qdisk";
534     xendev_class->device = "vbd";
535     xendev_class->get_name = xen_block_get_name;
536     xendev_class->realize = xen_block_realize;
537     xendev_class->frontend_changed = xen_block_frontend_changed;
538     xendev_class->unrealize = xen_block_unrealize;
539 
540     device_class_set_props(dev_class, xen_block_props);
541 }
542 
543 static const TypeInfo xen_block_type_info = {
544     .name = TYPE_XEN_BLOCK_DEVICE,
545     .parent = TYPE_XEN_DEVICE,
546     .instance_size = sizeof(XenBlockDevice),
547     .abstract = true,
548     .class_size = sizeof(XenBlockDeviceClass),
549     .class_init = xen_block_class_init,
550 };
551 
552 static void xen_disk_unrealize(XenBlockDevice *blockdev)
553 {
554     trace_xen_disk_unrealize();
555 }
556 
557 static void xen_disk_realize(XenBlockDevice *blockdev, Error **errp)
558 {
559     BlockConf *conf = &blockdev->props.conf;
560 
561     trace_xen_disk_realize();
562 
563     blockdev->device_type = "disk";
564 
565     if (!conf->blk) {
566         error_setg(errp, "drive property not set");
567         return;
568     }
569 
570     blockdev->info = blk_supports_write_perm(conf->blk) ? 0 : VDISK_READONLY;
571 }
572 
573 static void xen_disk_class_init(ObjectClass *class, void *data)
574 {
575     DeviceClass *dev_class = DEVICE_CLASS(class);
576     XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class);
577 
578     blockdev_class->realize = xen_disk_realize;
579     blockdev_class->unrealize = xen_disk_unrealize;
580 
581     dev_class->desc = "Xen Disk Device";
582 }
583 
584 static const TypeInfo xen_disk_type_info = {
585     .name = TYPE_XEN_DISK_DEVICE,
586     .parent = TYPE_XEN_BLOCK_DEVICE,
587     .instance_size = sizeof(XenDiskDevice),
588     .class_init = xen_disk_class_init,
589 };
590 
591 static void xen_cdrom_unrealize(XenBlockDevice *blockdev)
592 {
593     trace_xen_cdrom_unrealize();
594 }
595 
596 static void xen_cdrom_realize(XenBlockDevice *blockdev, Error **errp)
597 {
598     BlockConf *conf = &blockdev->props.conf;
599 
600     trace_xen_cdrom_realize();
601 
602     blockdev->device_type = "cdrom";
603 
604     if (!conf->blk) {
605         int rc;
606 
607         /* Set up an empty drive */
608         conf->blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
609 
610         rc = blk_attach_dev(conf->blk, DEVICE(blockdev));
611         if (!rc) {
612             error_setg_errno(errp, -rc, "failed to create drive");
613             return;
614         }
615     }
616 
617     blockdev->info = VDISK_READONLY | VDISK_CDROM;
618 }
619 
620 static void xen_cdrom_class_init(ObjectClass *class, void *data)
621 {
622     DeviceClass *dev_class = DEVICE_CLASS(class);
623     XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class);
624 
625     blockdev_class->realize = xen_cdrom_realize;
626     blockdev_class->unrealize = xen_cdrom_unrealize;
627 
628     dev_class->desc = "Xen CD-ROM Device";
629 }
630 
631 static const TypeInfo xen_cdrom_type_info = {
632     .name = TYPE_XEN_CDROM_DEVICE,
633     .parent = TYPE_XEN_BLOCK_DEVICE,
634     .instance_size = sizeof(XenCDRomDevice),
635     .class_init = xen_cdrom_class_init,
636 };
637 
638 static void xen_block_register_types(void)
639 {
640     type_register_static(&xen_block_type_info);
641     type_register_static(&xen_disk_type_info);
642     type_register_static(&xen_cdrom_type_info);
643 }
644 
645 type_init(xen_block_register_types)
646 
647 static void xen_block_blockdev_del(const char *node_name, Error **errp)
648 {
649     trace_xen_block_blockdev_del(node_name);
650 
651     qmp_blockdev_del(node_name, errp);
652 }
653 
654 static char *xen_block_blockdev_add(const char *id, QDict *qdict,
655                                     Error **errp)
656 {
657     ERRP_GUARD();
658     const char *driver = qdict_get_try_str(qdict, "driver");
659     BlockdevOptions *options = NULL;
660     char *node_name;
661     Visitor *v;
662 
663     if (!driver) {
664         error_setg(errp, "no 'driver' parameter");
665         return NULL;
666     }
667 
668     node_name = g_strdup_printf("%s-%s", id, driver);
669     qdict_put_str(qdict, "node-name", node_name);
670 
671     trace_xen_block_blockdev_add(node_name);
672 
673     v = qobject_input_visitor_new(QOBJECT(qdict));
674     visit_type_BlockdevOptions(v, NULL, &options, errp);
675     visit_free(v);
676     if (!options) {
677         goto fail;
678     }
679 
680     qmp_blockdev_add(options, errp);
681 
682     if (*errp) {
683         goto fail;
684     }
685 
686     qapi_free_BlockdevOptions(options);
687 
688     return node_name;
689 
690 fail:
691     if (options) {
692         qapi_free_BlockdevOptions(options);
693     }
694     g_free(node_name);
695 
696     return NULL;
697 }
698 
699 static void xen_block_drive_destroy(XenBlockDrive *drive, Error **errp)
700 {
701     ERRP_GUARD();
702     char *node_name = drive->node_name;
703 
704     if (node_name) {
705         xen_block_blockdev_del(node_name, errp);
706         if (*errp) {
707             return;
708         }
709         g_free(node_name);
710         drive->node_name = NULL;
711     }
712     g_free(drive->id);
713     g_free(drive);
714 }
715 
716 static XenBlockDrive *xen_block_drive_create(const char *id,
717                                              const char *device_type,
718                                              QDict *opts, Error **errp)
719 {
720     ERRP_GUARD();
721     const char *params = qdict_get_try_str(opts, "params");
722     const char *mode = qdict_get_try_str(opts, "mode");
723     const char *direct_io_safe = qdict_get_try_str(opts, "direct-io-safe");
724     const char *discard_enable = qdict_get_try_str(opts, "discard-enable");
725     char *driver = NULL;
726     char *filename = NULL;
727     XenBlockDrive *drive = NULL;
728     QDict *file_layer;
729     QDict *driver_layer;
730     struct stat st;
731     int rc;
732 
733     if (params) {
734         char **v = g_strsplit(params, ":", 2);
735 
736         if (v[1] == NULL) {
737             filename = g_strdup(v[0]);
738             driver = g_strdup("raw");
739         } else {
740             if (strcmp(v[0], "aio") == 0) {
741                 driver = g_strdup("raw");
742             } else if (strcmp(v[0], "vhd") == 0) {
743                 driver = g_strdup("vpc");
744             } else {
745                 driver = g_strdup(v[0]);
746             }
747             filename = g_strdup(v[1]);
748         }
749 
750         g_strfreev(v);
751     } else {
752         error_setg(errp, "no params");
753         goto done;
754     }
755 
756     assert(filename);
757     assert(driver);
758 
759     drive = g_new0(XenBlockDrive, 1);
760     drive->id = g_strdup(id);
761 
762     file_layer = qdict_new();
763     driver_layer = qdict_new();
764 
765     rc = stat(filename, &st);
766     if (rc) {
767         error_setg_errno(errp, errno, "Could not stat file '%s'", filename);
768         goto done;
769     }
770     if (S_ISBLK(st.st_mode)) {
771         qdict_put_str(file_layer, "driver", "host_device");
772     } else {
773         qdict_put_str(file_layer, "driver", "file");
774     }
775 
776     qdict_put_str(file_layer, "filename", filename);
777     g_free(filename);
778 
779     if (mode && *mode != 'w') {
780         qdict_put_bool(file_layer, "read-only", true);
781     }
782 
783     if (direct_io_safe) {
784         unsigned long value;
785 
786         if (!qemu_strtoul(direct_io_safe, NULL, 2, &value) && !!value) {
787             QDict *cache_qdict = qdict_new();
788 
789             qdict_put_bool(cache_qdict, "direct", true);
790             qdict_put(file_layer, "cache", cache_qdict);
791 
792             qdict_put_str(file_layer, "aio", "native");
793         }
794     }
795 
796     if (discard_enable) {
797         unsigned long value;
798 
799         if (!qemu_strtoul(discard_enable, NULL, 2, &value) && !!value) {
800             qdict_put_str(file_layer, "discard", "unmap");
801             qdict_put_str(driver_layer, "discard", "unmap");
802         }
803     }
804 
805     /*
806      * It is necessary to turn file locking off as an emulated device
807      * may have already opened the same image file.
808      */
809     qdict_put_str(file_layer, "locking", "off");
810 
811     qdict_put_str(driver_layer, "driver", driver);
812     g_free(driver);
813 
814     qdict_put(driver_layer, "file", file_layer);
815 
816     g_assert(!drive->node_name);
817     drive->node_name = xen_block_blockdev_add(drive->id, driver_layer,
818                                               errp);
819 
820     qobject_unref(driver_layer);
821 
822 done:
823     if (*errp) {
824         xen_block_drive_destroy(drive, NULL);
825         return NULL;
826     }
827 
828     return drive;
829 }
830 
831 static const char *xen_block_drive_get_node_name(XenBlockDrive *drive)
832 {
833     return drive->node_name ? drive->node_name : "";
834 }
835 
836 static void xen_block_iothread_destroy(XenBlockIOThread *iothread,
837                                        Error **errp)
838 {
839     qmp_object_del(iothread->id, errp);
840 
841     g_free(iothread->id);
842     g_free(iothread);
843 }
844 
845 static XenBlockIOThread *xen_block_iothread_create(const char *id,
846                                                    Error **errp)
847 {
848     ERRP_GUARD();
849     XenBlockIOThread *iothread = g_new(XenBlockIOThread, 1);
850     ObjectOptions *opts;
851 
852     iothread->id = g_strdup(id);
853 
854     opts = g_new(ObjectOptions, 1);
855     *opts = (ObjectOptions) {
856         .qom_type = OBJECT_TYPE_IOTHREAD,
857         .id = g_strdup(id),
858     };
859     qmp_object_add(opts, errp);
860     qapi_free_ObjectOptions(opts);
861 
862     if (*errp) {
863         g_free(iothread->id);
864         g_free(iothread);
865         return NULL;
866     }
867 
868     return iothread;
869 }
870 
871 static void xen_block_device_create(XenBackendInstance *backend,
872                                     QDict *opts, Error **errp)
873 {
874     ERRP_GUARD();
875     XenBus *xenbus = xen_backend_get_bus(backend);
876     const char *name = xen_backend_get_name(backend);
877     unsigned long number;
878     const char *vdev, *device_type;
879     XenBlockDrive *drive = NULL;
880     XenBlockIOThread *iothread = NULL;
881     XenDevice *xendev = NULL;
882     const char *type;
883     XenBlockDevice *blockdev;
884 
885     if (qemu_strtoul(name, NULL, 10, &number)) {
886         error_setg(errp, "failed to parse name '%s'", name);
887         goto fail;
888     }
889 
890     trace_xen_block_device_create(number);
891 
892     vdev = qdict_get_try_str(opts, "dev");
893     if (!vdev) {
894         error_setg(errp, "no dev parameter");
895         goto fail;
896     }
897 
898     device_type = qdict_get_try_str(opts, "device-type");
899     if (!device_type) {
900         error_setg(errp, "no device-type parameter");
901         goto fail;
902     }
903 
904     if (!strcmp(device_type, "disk")) {
905         type = TYPE_XEN_DISK_DEVICE;
906     } else if (!strcmp(device_type, "cdrom")) {
907         type = TYPE_XEN_CDROM_DEVICE;
908     } else {
909         error_setg(errp, "invalid device-type parameter '%s'", device_type);
910         goto fail;
911     }
912 
913     drive = xen_block_drive_create(vdev, device_type, opts, errp);
914     if (!drive) {
915         error_prepend(errp, "failed to create drive: ");
916         goto fail;
917     }
918 
919     iothread = xen_block_iothread_create(vdev, errp);
920     if (*errp) {
921         error_prepend(errp, "failed to create iothread: ");
922         goto fail;
923     }
924 
925     xendev = XEN_DEVICE(qdev_new(type));
926     blockdev = XEN_BLOCK_DEVICE(xendev);
927 
928     if (!object_property_set_str(OBJECT(xendev), "vdev", vdev,
929                                  errp)) {
930         error_prepend(errp, "failed to set 'vdev': ");
931         goto fail;
932     }
933 
934     if (!object_property_set_str(OBJECT(xendev), "drive",
935                                  xen_block_drive_get_node_name(drive),
936                                  errp)) {
937         error_prepend(errp, "failed to set 'drive': ");
938         goto fail;
939     }
940 
941     if (!object_property_set_str(OBJECT(xendev), "iothread", iothread->id,
942                                  errp)) {
943         error_prepend(errp, "failed to set 'iothread': ");
944         goto fail;
945     }
946 
947     blockdev->iothread = iothread;
948     blockdev->drive = drive;
949 
950     if (!qdev_realize_and_unref(DEVICE(xendev), BUS(xenbus), errp)) {
951         error_prepend(errp, "realization of device %s failed: ", type);
952         goto fail;
953     }
954 
955     xen_backend_set_device(backend, xendev);
956     return;
957 
958 fail:
959     if (xendev) {
960         object_unparent(OBJECT(xendev));
961     }
962 
963     if (iothread) {
964         xen_block_iothread_destroy(iothread, NULL);
965     }
966 
967     if (drive) {
968         xen_block_drive_destroy(drive, NULL);
969     }
970 }
971 
972 static void xen_block_device_destroy(XenBackendInstance *backend,
973                                      Error **errp)
974 {
975     ERRP_GUARD();
976     XenDevice *xendev = xen_backend_get_device(backend);
977     XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
978     XenBlockVdev *vdev = &blockdev->props.vdev;
979     XenBlockDrive *drive = blockdev->drive;
980     XenBlockIOThread *iothread = blockdev->iothread;
981 
982     trace_xen_block_device_destroy(vdev->number);
983 
984     object_unparent(OBJECT(xendev));
985 
986     /*
987      * Drain all pending RCU callbacks as object_unparent() frees `xendev'
988      * in a RCU callback.
989      * And due to the property "drive" still existing in `xendev', we
990      * can't destroy the XenBlockDrive associated with `xendev' with
991      * xen_block_drive_destroy() below.
992      */
993     drain_call_rcu();
994 
995     if (iothread) {
996         xen_block_iothread_destroy(iothread, errp);
997         if (*errp) {
998             error_prepend(errp, "failed to destroy iothread: ");
999             return;
1000         }
1001     }
1002 
1003     if (drive) {
1004         xen_block_drive_destroy(drive, errp);
1005         if (*errp) {
1006             error_prepend(errp, "failed to destroy drive: ");
1007             return;
1008         }
1009     }
1010 }
1011 
1012 static const XenBackendInfo xen_block_backend_info = {
1013     .type = "qdisk",
1014     .create = xen_block_device_create,
1015     .destroy = xen_block_device_destroy,
1016 };
1017 
1018 static void xen_block_register_backend(void)
1019 {
1020     xen_backend_register(&xen_block_backend_info);
1021 }
1022 
1023 xen_backend_init(xen_block_register_backend);
1024