2 * Copyright (c) 2018 Citrix Systems Inc.
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.
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/block/xen_blkif.h"
23 #include "hw/qdev-properties.h"
24 #include "hw/xen/xen-block.h"
25 #include "hw/xen/xen-backend.h"
26 #include "sysemu/blockdev.h"
27 #include "sysemu/block-backend.h"
28 #include "sysemu/iothread.h"
29 #include "dataplane/xen-block.h"
32 static char *xen_block_get_name(XenDevice
*xendev
, Error
**errp
)
34 XenBlockDevice
*blockdev
= XEN_BLOCK_DEVICE(xendev
);
35 XenBlockVdev
*vdev
= &blockdev
->props
.vdev
;
37 return g_strdup_printf("%lu", vdev
->number
);
40 static void xen_block_disconnect(XenDevice
*xendev
, Error
**errp
)
42 XenBlockDevice
*blockdev
= XEN_BLOCK_DEVICE(xendev
);
43 const char *type
= object_get_typename(OBJECT(blockdev
));
44 XenBlockVdev
*vdev
= &blockdev
->props
.vdev
;
46 trace_xen_block_disconnect(type
, vdev
->disk
, vdev
->partition
);
48 xen_block_dataplane_stop(blockdev
->dataplane
);
51 static void xen_block_connect(XenDevice
*xendev
, Error
**errp
)
53 XenBlockDevice
*blockdev
= XEN_BLOCK_DEVICE(xendev
);
54 const char *type
= object_get_typename(OBJECT(blockdev
));
55 XenBlockVdev
*vdev
= &blockdev
->props
.vdev
;
56 BlockConf
*conf
= &blockdev
->props
.conf
;
57 unsigned int feature_large_sector_size
;
58 unsigned int order
, nr_ring_ref
, *ring_ref
, event_channel
, protocol
;
61 trace_xen_block_connect(type
, vdev
->disk
, vdev
->partition
);
63 if (xen_device_frontend_scanf(xendev
, "feature-large-sector-size", "%u",
64 &feature_large_sector_size
) != 1) {
65 feature_large_sector_size
= 0;
68 if (feature_large_sector_size
!= 1 &&
69 conf
->logical_block_size
!= XEN_BLKIF_SECTOR_SIZE
) {
70 error_setg(errp
, "logical_block_size != %u not supported by frontend",
71 XEN_BLKIF_SECTOR_SIZE
);
75 if (xen_device_frontend_scanf(xendev
, "ring-page-order", "%u",
78 ring_ref
= g_new(unsigned int, nr_ring_ref
);
80 if (xen_device_frontend_scanf(xendev
, "ring-ref", "%u",
82 error_setg(errp
, "failed to read ring-ref");
86 } else if (qemu_xen_gnttab_can_map_multi() &&
87 order
<= blockdev
->props
.max_ring_page_order
) {
90 nr_ring_ref
= 1 << order
;
91 ring_ref
= g_new(unsigned int, nr_ring_ref
);
93 for (i
= 0; i
< nr_ring_ref
; i
++) {
94 const char *key
= g_strdup_printf("ring-ref%u", i
);
96 if (xen_device_frontend_scanf(xendev
, key
, "%u",
98 error_setg(errp
, "failed to read %s", key
);
99 g_free((gpointer
)key
);
104 g_free((gpointer
)key
);
107 error_setg(errp
, "invalid ring-page-order (%d)", order
);
111 if (xen_device_frontend_scanf(xendev
, "event-channel", "%u",
112 &event_channel
) != 1) {
113 error_setg(errp
, "failed to read event-channel");
118 if (xen_device_frontend_scanf(xendev
, "protocol", "%ms",
120 protocol
= BLKIF_PROTOCOL_NATIVE
;
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
;
127 protocol
= BLKIF_PROTOCOL_NATIVE
;
133 xen_block_dataplane_start(blockdev
->dataplane
, ring_ref
, nr_ring_ref
,
134 event_channel
, protocol
, errp
);
139 static void xen_block_unrealize(XenDevice
*xendev
)
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
;
147 if (vdev
->type
== XEN_BLOCK_VDEV_TYPE_INVALID
) {
151 trace_xen_block_unrealize(type
, vdev
->disk
, vdev
->partition
);
153 /* Disconnect from the frontend in case this has not already happened */
154 xen_block_disconnect(xendev
, NULL
);
156 xen_block_dataplane_destroy(blockdev
->dataplane
);
157 blockdev
->dataplane
= NULL
;
159 if (blockdev_class
->unrealize
) {
160 blockdev_class
->unrealize(blockdev
);
164 static void xen_block_set_size(XenBlockDevice
*blockdev
)
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
);
172 trace_xen_block_size(type
, vdev
->disk
, vdev
->partition
, sectors
);
174 xen_device_backend_printf(xendev
, "sectors", "%"PRIi64
, sectors
);
177 static void xen_block_resize_cb(void *opaque
)
179 XenBlockDevice
*blockdev
= opaque
;
180 XenDevice
*xendev
= XEN_DEVICE(blockdev
);
181 enum xenbus_state state
= xen_device_backend_get_state(xendev
);
183 xen_block_set_size(blockdev
);
186 * Mimic the behaviour of Linux xen-blkback and re-write the state
187 * to trigger the frontend watch.
189 xen_device_backend_printf(xendev
, "state", "%u", state
);
192 /* Suspend request handling */
193 static void xen_block_drained_begin(void *opaque
)
195 XenBlockDevice
*blockdev
= opaque
;
197 xen_block_dataplane_detach(blockdev
->dataplane
);
200 /* Resume request handling */
201 static void xen_block_drained_end(void *opaque
)
203 XenBlockDevice
*blockdev
= opaque
;
205 xen_block_dataplane_attach(blockdev
->dataplane
);
208 static const BlockDevOps xen_block_dev_ops
= {
209 .resize_cb
= xen_block_resize_cb
,
210 .drained_begin
= xen_block_drained_begin
,
211 .drained_end
= xen_block_drained_end
,
214 static void xen_block_realize(XenDevice
*xendev
, Error
**errp
)
217 XenBlockDevice
*blockdev
= XEN_BLOCK_DEVICE(xendev
);
218 XenBlockDeviceClass
*blockdev_class
=
219 XEN_BLOCK_DEVICE_GET_CLASS(xendev
);
220 const char *type
= object_get_typename(OBJECT(blockdev
));
221 XenBlockVdev
*vdev
= &blockdev
->props
.vdev
;
222 BlockConf
*conf
= &blockdev
->props
.conf
;
223 BlockBackend
*blk
= conf
->blk
;
225 if (vdev
->type
== XEN_BLOCK_VDEV_TYPE_INVALID
) {
226 error_setg(errp
, "vdev property not set");
230 trace_xen_block_realize(type
, vdev
->disk
, vdev
->partition
);
232 if (blockdev_class
->realize
) {
233 blockdev_class
->realize(blockdev
, errp
);
240 * The blkif protocol does not deal with removable media, so it must
241 * always be present, even for CDRom devices.
244 if (!blk_is_inserted(blk
)) {
245 error_setg(errp
, "device needs media, but drive is empty");
249 if (!blkconf_apply_backend_options(conf
, blockdev
->info
& VDISK_READONLY
,
254 if (!(blockdev
->info
& VDISK_CDROM
) &&
255 !blkconf_geometry(conf
, NULL
, 65535, 255, 255, errp
)) {
259 if (!blkconf_blocksizes(conf
, errp
)) {
263 if (conf
->discard_granularity
== -1) {
264 conf
->discard_granularity
= conf
->physical_block_size
;
267 if (blk_get_flags(blk
) & BDRV_O_UNMAP
) {
268 xen_device_backend_printf(xendev
, "feature-discard", "%u", 1);
269 xen_device_backend_printf(xendev
, "discard-granularity", "%u",
270 conf
->discard_granularity
);
271 xen_device_backend_printf(xendev
, "discard-alignment", "%u", 0);
274 xen_device_backend_printf(xendev
, "feature-flush-cache", "%u", 1);
276 if (qemu_xen_gnttab_can_map_multi()) {
277 xen_device_backend_printf(xendev
, "max-ring-page-order", "%u",
278 blockdev
->props
.max_ring_page_order
);
281 xen_device_backend_printf(xendev
, "info", "%u", blockdev
->info
);
283 xen_device_frontend_printf(xendev
, "virtual-device", "%lu",
285 xen_device_frontend_printf(xendev
, "device-type", "%s",
286 blockdev
->device_type
);
288 xen_device_backend_printf(xendev
, "sector-size", "%u",
289 conf
->logical_block_size
);
291 xen_block_set_size(blockdev
);
293 blockdev
->dataplane
=
294 xen_block_dataplane_create(xendev
, blk
, conf
->logical_block_size
,
295 blockdev
->props
.iothread
);
297 blk_set_dev_ops(blk
, &xen_block_dev_ops
, blockdev
);
300 static void xen_block_frontend_changed(XenDevice
*xendev
,
301 enum xenbus_state frontend_state
,
305 enum xenbus_state backend_state
= xen_device_backend_get_state(xendev
);
307 switch (frontend_state
) {
308 case XenbusStateInitialised
:
309 case XenbusStateConnected
:
310 if (backend_state
== XenbusStateConnected
) {
314 xen_block_disconnect(xendev
, errp
);
319 xen_block_connect(xendev
, errp
);
324 xen_device_backend_set_state(xendev
, XenbusStateConnected
);
327 case XenbusStateClosing
:
328 xen_device_backend_set_state(xendev
, XenbusStateClosing
);
331 case XenbusStateClosed
:
332 case XenbusStateUnknown
:
333 xen_block_disconnect(xendev
, errp
);
338 xen_device_backend_set_state(xendev
, XenbusStateClosed
);
346 static char *disk_to_vbd_name(unsigned int disk
)
348 char *name
, *prefix
= (disk
>= 26) ?
349 disk_to_vbd_name((disk
/ 26) - 1) : g_strdup("");
351 name
= g_strdup_printf("%s%c", prefix
, 'a' + disk
% 26);
357 static void xen_block_get_vdev(Object
*obj
, Visitor
*v
, const char *name
,
358 void *opaque
, Error
**errp
)
360 Property
*prop
= opaque
;
361 XenBlockVdev
*vdev
= object_field_prop_ptr(obj
, prop
);
364 switch (vdev
->type
) {
365 case XEN_BLOCK_VDEV_TYPE_DP
:
366 str
= g_strdup_printf("d%lup%lu", vdev
->disk
, vdev
->partition
);
369 case XEN_BLOCK_VDEV_TYPE_XVD
:
370 case XEN_BLOCK_VDEV_TYPE_HD
:
371 case XEN_BLOCK_VDEV_TYPE_SD
: {
372 char *name
= disk_to_vbd_name(vdev
->disk
);
374 str
= g_strdup_printf("%s%s%lu",
375 (vdev
->type
== XEN_BLOCK_VDEV_TYPE_XVD
) ?
377 (vdev
->type
== XEN_BLOCK_VDEV_TYPE_HD
) ?
380 name
, vdev
->partition
);
385 error_setg(errp
, "invalid vdev type");
389 visit_type_str(v
, name
, &str
, errp
);
393 static int vbd_name_to_disk(const char *name
, const char **endp
,
398 while (*name
!= '\0') {
399 if (!g_ascii_isalpha(*name
) || !g_ascii_islower(*name
)) {
404 n
+= *name
++ - 'a' + 1;
417 static void xen_block_set_vdev(Object
*obj
, Visitor
*v
, const char *name
,
418 void *opaque
, Error
**errp
)
420 Property
*prop
= opaque
;
421 XenBlockVdev
*vdev
= object_field_prop_ptr(obj
, prop
);
425 if (!visit_type_str(v
, name
, &str
, errp
)) {
429 p
= strchr(str
, 'd');
436 vdev
->type
= XEN_BLOCK_VDEV_TYPE_DP
;
437 } else if (strcmp(str
, "xv") == 0) {
438 vdev
->type
= XEN_BLOCK_VDEV_TYPE_XVD
;
439 } else if (strcmp(str
, "h") == 0) {
440 vdev
->type
= XEN_BLOCK_VDEV_TYPE_HD
;
441 } else if (strcmp(str
, "s") == 0) {
442 vdev
->type
= XEN_BLOCK_VDEV_TYPE_SD
;
447 if (vdev
->type
== XEN_BLOCK_VDEV_TYPE_DP
) {
448 if (qemu_strtoul(p
, &end
, 10, &vdev
->disk
)) {
453 if (*(++end
) == '\0') {
458 if (vbd_name_to_disk(p
, &end
, &vdev
->disk
)) {
466 if (qemu_strtoul(p
, &end
, 10, &vdev
->partition
)) {
477 switch (vdev
->type
) {
478 case XEN_BLOCK_VDEV_TYPE_DP
:
479 case XEN_BLOCK_VDEV_TYPE_XVD
:
480 if (vdev
->disk
< (1 << 4) && vdev
->partition
< (1 << 4)) {
481 vdev
->number
= (202 << 8) | (vdev
->disk
<< 4) |
483 } else if (vdev
->disk
< (1 << 20) && vdev
->partition
< (1 << 8)) {
484 vdev
->number
= (1 << 28) | (vdev
->disk
<< 8) |
491 case XEN_BLOCK_VDEV_TYPE_HD
:
492 if ((vdev
->disk
== 0 || vdev
->disk
== 1) &&
493 vdev
->partition
< (1 << 6)) {
494 vdev
->number
= (3 << 8) | (vdev
->disk
<< 6) | vdev
->partition
;
495 } else if ((vdev
->disk
== 2 || vdev
->disk
== 3) &&
496 vdev
->partition
< (1 << 6)) {
497 vdev
->number
= (22 << 8) | ((vdev
->disk
- 2) << 6) |
504 case XEN_BLOCK_VDEV_TYPE_SD
:
505 if (vdev
->disk
< (1 << 4) && vdev
->partition
< (1 << 4)) {
506 vdev
->number
= (8 << 8) | (vdev
->disk
<< 4) | vdev
->partition
;
520 error_setg(errp
, "invalid virtual disk specifier");
522 vdev
->type
= XEN_BLOCK_VDEV_TYPE_INVALID
;
527 * This property deals with 'vdev' names adhering to the Xen VBD naming
528 * scheme described in:
530 * https://xenbits.xen.org/docs/unstable/man/xen-vbd-interface.7.html
532 const PropertyInfo xen_block_prop_vdev
= {
534 .description
= "Virtual Disk specifier: d*p*/xvd*/hd*/sd*",
535 .get
= xen_block_get_vdev
,
536 .set
= xen_block_set_vdev
,
539 static Property xen_block_props
[] = {
540 DEFINE_PROP("vdev", XenBlockDevice
, props
.vdev
,
541 xen_block_prop_vdev
, XenBlockVdev
),
542 DEFINE_BLOCK_PROPERTIES(XenBlockDevice
, props
.conf
),
543 DEFINE_PROP_UINT32("max-ring-page-order", XenBlockDevice
,
544 props
.max_ring_page_order
, 4),
545 DEFINE_PROP_LINK("iothread", XenBlockDevice
, props
.iothread
,
546 TYPE_IOTHREAD
, IOThread
*),
547 DEFINE_PROP_END_OF_LIST()
550 static void xen_block_class_init(ObjectClass
*class, void *data
)
552 DeviceClass
*dev_class
= DEVICE_CLASS(class);
553 XenDeviceClass
*xendev_class
= XEN_DEVICE_CLASS(class);
555 xendev_class
->backend
= "qdisk";
556 xendev_class
->device
= "vbd";
557 xendev_class
->get_name
= xen_block_get_name
;
558 xendev_class
->realize
= xen_block_realize
;
559 xendev_class
->frontend_changed
= xen_block_frontend_changed
;
560 xendev_class
->unrealize
= xen_block_unrealize
;
562 device_class_set_props(dev_class
, xen_block_props
);
565 static const TypeInfo xen_block_type_info
= {
566 .name
= TYPE_XEN_BLOCK_DEVICE
,
567 .parent
= TYPE_XEN_DEVICE
,
568 .instance_size
= sizeof(XenBlockDevice
),
570 .class_size
= sizeof(XenBlockDeviceClass
),
571 .class_init
= xen_block_class_init
,
574 static void xen_disk_unrealize(XenBlockDevice
*blockdev
)
576 trace_xen_disk_unrealize();
579 static void xen_disk_realize(XenBlockDevice
*blockdev
, Error
**errp
)
581 BlockConf
*conf
= &blockdev
->props
.conf
;
583 trace_xen_disk_realize();
585 blockdev
->device_type
= "disk";
588 error_setg(errp
, "drive property not set");
592 blockdev
->info
= blk_supports_write_perm(conf
->blk
) ? 0 : VDISK_READONLY
;
595 static void xen_disk_class_init(ObjectClass
*class, void *data
)
597 DeviceClass
*dev_class
= DEVICE_CLASS(class);
598 XenBlockDeviceClass
*blockdev_class
= XEN_BLOCK_DEVICE_CLASS(class);
600 blockdev_class
->realize
= xen_disk_realize
;
601 blockdev_class
->unrealize
= xen_disk_unrealize
;
603 dev_class
->desc
= "Xen Disk Device";
606 static const TypeInfo xen_disk_type_info
= {
607 .name
= TYPE_XEN_DISK_DEVICE
,
608 .parent
= TYPE_XEN_BLOCK_DEVICE
,
609 .instance_size
= sizeof(XenDiskDevice
),
610 .class_init
= xen_disk_class_init
,
613 static void xen_cdrom_unrealize(XenBlockDevice
*blockdev
)
615 trace_xen_cdrom_unrealize();
618 static void xen_cdrom_realize(XenBlockDevice
*blockdev
, Error
**errp
)
620 BlockConf
*conf
= &blockdev
->props
.conf
;
622 trace_xen_cdrom_realize();
624 blockdev
->device_type
= "cdrom";
629 /* Set up an empty drive */
630 conf
->blk
= blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL
);
632 rc
= blk_attach_dev(conf
->blk
, DEVICE(blockdev
));
634 error_setg_errno(errp
, -rc
, "failed to create drive");
639 blockdev
->info
= VDISK_READONLY
| VDISK_CDROM
;
642 static void xen_cdrom_class_init(ObjectClass
*class, void *data
)
644 DeviceClass
*dev_class
= DEVICE_CLASS(class);
645 XenBlockDeviceClass
*blockdev_class
= XEN_BLOCK_DEVICE_CLASS(class);
647 blockdev_class
->realize
= xen_cdrom_realize
;
648 blockdev_class
->unrealize
= xen_cdrom_unrealize
;
650 dev_class
->desc
= "Xen CD-ROM Device";
653 static const TypeInfo xen_cdrom_type_info
= {
654 .name
= TYPE_XEN_CDROM_DEVICE
,
655 .parent
= TYPE_XEN_BLOCK_DEVICE
,
656 .instance_size
= sizeof(XenCDRomDevice
),
657 .class_init
= xen_cdrom_class_init
,
660 static void xen_block_register_types(void)
662 type_register_static(&xen_block_type_info
);
663 type_register_static(&xen_disk_type_info
);
664 type_register_static(&xen_cdrom_type_info
);
667 type_init(xen_block_register_types
)
669 static void xen_block_blockdev_del(const char *node_name
, Error
**errp
)
671 trace_xen_block_blockdev_del(node_name
);
673 qmp_blockdev_del(node_name
, errp
);
676 static char *xen_block_blockdev_add(const char *id
, QDict
*qdict
,
680 const char *driver
= qdict_get_try_str(qdict
, "driver");
681 BlockdevOptions
*options
= NULL
;
686 error_setg(errp
, "no 'driver' parameter");
690 node_name
= g_strdup_printf("%s-%s", id
, driver
);
691 qdict_put_str(qdict
, "node-name", node_name
);
693 trace_xen_block_blockdev_add(node_name
);
695 v
= qobject_input_visitor_new(QOBJECT(qdict
));
696 visit_type_BlockdevOptions(v
, NULL
, &options
, errp
);
702 qmp_blockdev_add(options
, errp
);
708 qapi_free_BlockdevOptions(options
);
714 qapi_free_BlockdevOptions(options
);
721 static void xen_block_drive_destroy(XenBlockDrive
*drive
, Error
**errp
)
724 char *node_name
= drive
->node_name
;
727 xen_block_blockdev_del(node_name
, errp
);
732 drive
->node_name
= NULL
;
738 static XenBlockDrive
*xen_block_drive_create(const char *id
,
739 const char *device_type
,
740 QDict
*opts
, Error
**errp
)
743 const char *params
= qdict_get_try_str(opts
, "params");
744 const char *mode
= qdict_get_try_str(opts
, "mode");
745 const char *direct_io_safe
= qdict_get_try_str(opts
, "direct-io-safe");
746 const char *discard_enable
= qdict_get_try_str(opts
, "discard-enable");
748 char *filename
= NULL
;
749 XenBlockDrive
*drive
= NULL
;
756 char **v
= g_strsplit(params
, ":", 2);
759 filename
= g_strdup(v
[0]);
760 driver
= g_strdup("raw");
762 if (strcmp(v
[0], "aio") == 0) {
763 driver
= g_strdup("raw");
764 } else if (strcmp(v
[0], "vhd") == 0) {
765 driver
= g_strdup("vpc");
767 driver
= g_strdup(v
[0]);
769 filename
= g_strdup(v
[1]);
774 error_setg(errp
, "no params");
781 drive
= g_new0(XenBlockDrive
, 1);
782 drive
->id
= g_strdup(id
);
784 file_layer
= qdict_new();
785 driver_layer
= qdict_new();
787 rc
= stat(filename
, &st
);
789 error_setg_errno(errp
, errno
, "Could not stat file '%s'", filename
);
792 if (S_ISBLK(st
.st_mode
)) {
793 qdict_put_str(file_layer
, "driver", "host_device");
795 qdict_put_str(file_layer
, "driver", "file");
798 qdict_put_str(file_layer
, "filename", filename
);
801 if (mode
&& *mode
!= 'w') {
802 qdict_put_bool(file_layer
, "read-only", true);
805 if (direct_io_safe
) {
808 if (!qemu_strtoul(direct_io_safe
, NULL
, 2, &value
) && !!value
) {
809 QDict
*cache_qdict
= qdict_new();
811 qdict_put_bool(cache_qdict
, "direct", true);
812 qdict_put(file_layer
, "cache", cache_qdict
);
814 qdict_put_str(file_layer
, "aio", "native");
818 if (discard_enable
) {
821 if (!qemu_strtoul(discard_enable
, NULL
, 2, &value
) && !!value
) {
822 qdict_put_str(file_layer
, "discard", "unmap");
823 qdict_put_str(driver_layer
, "discard", "unmap");
828 * It is necessary to turn file locking off as an emulated device
829 * may have already opened the same image file.
831 qdict_put_str(file_layer
, "locking", "off");
833 qdict_put_str(driver_layer
, "driver", driver
);
836 qdict_put(driver_layer
, "file", file_layer
);
838 g_assert(!drive
->node_name
);
839 drive
->node_name
= xen_block_blockdev_add(drive
->id
, driver_layer
,
842 qobject_unref(driver_layer
);
846 xen_block_drive_destroy(drive
, NULL
);
853 static const char *xen_block_drive_get_node_name(XenBlockDrive
*drive
)
855 return drive
->node_name
? drive
->node_name
: "";
858 static void xen_block_iothread_destroy(XenBlockIOThread
*iothread
,
861 qmp_object_del(iothread
->id
, errp
);
863 g_free(iothread
->id
);
867 static XenBlockIOThread
*xen_block_iothread_create(const char *id
,
871 XenBlockIOThread
*iothread
= g_new(XenBlockIOThread
, 1);
874 iothread
->id
= g_strdup(id
);
876 opts
= g_new(ObjectOptions
, 1);
877 *opts
= (ObjectOptions
) {
878 .qom_type
= OBJECT_TYPE_IOTHREAD
,
881 qmp_object_add(opts
, errp
);
882 qapi_free_ObjectOptions(opts
);
885 g_free(iothread
->id
);
893 static void xen_block_device_create(XenBackendInstance
*backend
,
894 QDict
*opts
, Error
**errp
)
897 XenBus
*xenbus
= xen_backend_get_bus(backend
);
898 const char *name
= xen_backend_get_name(backend
);
899 unsigned long number
;
900 const char *vdev
, *device_type
;
901 XenBlockDrive
*drive
= NULL
;
902 XenBlockIOThread
*iothread
= NULL
;
903 XenDevice
*xendev
= NULL
;
905 XenBlockDevice
*blockdev
;
907 if (qemu_strtoul(name
, NULL
, 10, &number
)) {
908 error_setg(errp
, "failed to parse name '%s'", name
);
912 trace_xen_block_device_create(number
);
914 vdev
= qdict_get_try_str(opts
, "dev");
916 error_setg(errp
, "no dev parameter");
920 device_type
= qdict_get_try_str(opts
, "device-type");
922 error_setg(errp
, "no device-type parameter");
926 if (!strcmp(device_type
, "disk")) {
927 type
= TYPE_XEN_DISK_DEVICE
;
928 } else if (!strcmp(device_type
, "cdrom")) {
929 type
= TYPE_XEN_CDROM_DEVICE
;
931 error_setg(errp
, "invalid device-type parameter '%s'", device_type
);
935 drive
= xen_block_drive_create(vdev
, device_type
, opts
, errp
);
937 error_prepend(errp
, "failed to create drive: ");
941 iothread
= xen_block_iothread_create(vdev
, errp
);
943 error_prepend(errp
, "failed to create iothread: ");
947 xendev
= XEN_DEVICE(qdev_new(type
));
948 blockdev
= XEN_BLOCK_DEVICE(xendev
);
950 if (!object_property_set_str(OBJECT(xendev
), "vdev", vdev
,
952 error_prepend(errp
, "failed to set 'vdev': ");
956 if (!object_property_set_str(OBJECT(xendev
), "drive",
957 xen_block_drive_get_node_name(drive
),
959 error_prepend(errp
, "failed to set 'drive': ");
963 if (!object_property_set_str(OBJECT(xendev
), "iothread", iothread
->id
,
965 error_prepend(errp
, "failed to set 'iothread': ");
969 blockdev
->iothread
= iothread
;
970 blockdev
->drive
= drive
;
972 if (!qdev_realize_and_unref(DEVICE(xendev
), BUS(xenbus
), errp
)) {
973 error_prepend(errp
, "realization of device %s failed: ", type
);
977 xen_backend_set_device(backend
, xendev
);
982 object_unparent(OBJECT(xendev
));
986 xen_block_iothread_destroy(iothread
, NULL
);
990 xen_block_drive_destroy(drive
, NULL
);
994 static void xen_block_device_destroy(XenBackendInstance
*backend
,
998 XenDevice
*xendev
= xen_backend_get_device(backend
);
999 XenBlockDevice
*blockdev
= XEN_BLOCK_DEVICE(xendev
);
1000 XenBlockVdev
*vdev
= &blockdev
->props
.vdev
;
1001 XenBlockDrive
*drive
= blockdev
->drive
;
1002 XenBlockIOThread
*iothread
= blockdev
->iothread
;
1004 trace_xen_block_device_destroy(vdev
->number
);
1006 object_unparent(OBJECT(xendev
));
1009 * Drain all pending RCU callbacks as object_unparent() frees `xendev'
1010 * in a RCU callback.
1011 * And due to the property "drive" still existing in `xendev', we
1012 * can't destroy the XenBlockDrive associated with `xendev' with
1013 * xen_block_drive_destroy() below.
1018 xen_block_iothread_destroy(iothread
, errp
);
1020 error_prepend(errp
, "failed to destroy iothread: ");
1026 xen_block_drive_destroy(drive
, errp
);
1028 error_prepend(errp
, "failed to destroy drive: ");
1034 static const XenBackendInfo xen_block_backend_info
= {
1036 .create
= xen_block_device_create
,
1037 .destroy
= xen_block_device_destroy
,
1040 static void xen_block_register_backend(void)
1042 xen_backend_register(&xen_block_backend_info
);
1045 xen_backend_init(xen_block_register_backend
);