11a72d9aeSPaul Durrant /*
21a72d9aeSPaul Durrant * Copyright (c) 2018 Citrix Systems Inc.
31a72d9aeSPaul Durrant *
41a72d9aeSPaul Durrant * This work is licensed under the terms of the GNU GPL, version 2 or later.
51a72d9aeSPaul Durrant * See the COPYING file in the top-level directory.
61a72d9aeSPaul Durrant */
71a72d9aeSPaul Durrant
81a72d9aeSPaul Durrant #include "qemu/osdep.h"
91a72d9aeSPaul Durrant #include "qemu/cutils.h"
10db725815SMarkus Armbruster #include "qemu/main-loop.h"
110b8fa32fSMarkus Armbruster #include "qemu/module.h"
12db9ff46eSPaul Durrant #include "qemu/option.h"
131a72d9aeSPaul Durrant #include "qapi/error.h"
14db9ff46eSPaul Durrant #include "qapi/qapi-commands-block-core.h"
15c577ff62SMarkus Armbruster #include "qapi/qapi-commands-qom.h"
16db9ff46eSPaul Durrant #include "qapi/qapi-visit-block-core.h"
17db9ff46eSPaul Durrant #include "qapi/qobject-input-visitor.h"
181a72d9aeSPaul Durrant #include "qapi/visitor.h"
19db9ff46eSPaul Durrant #include "qapi/qmp/qdict.h"
20db9ff46eSPaul Durrant #include "qapi/qmp/qstring.h"
215f07c4d6SKevin Wolf #include "qom/object_interfaces.h"
22b6af8926SPaul Durrant #include "hw/block/xen_blkif.h"
23a27bd6c7SMarkus Armbruster #include "hw/qdev-properties.h"
241a72d9aeSPaul Durrant #include "hw/xen/xen-block.h"
25db9ff46eSPaul Durrant #include "hw/xen/xen-backend.h"
26b6af8926SPaul Durrant #include "sysemu/blockdev.h"
27b6af8926SPaul Durrant #include "sysemu/block-backend.h"
28b6af8926SPaul Durrant #include "sysemu/iothread.h"
29b6af8926SPaul Durrant #include "dataplane/xen-block.h"
30d3256f88SDavid Woodhouse #include "hw/xen/interface/io/xs_wire.h"
311a72d9aeSPaul Durrant #include "trace.h"
321a72d9aeSPaul Durrant
33d3256f88SDavid Woodhouse #define XVDA_MAJOR 202
34d3256f88SDavid Woodhouse #define XVDQ_MAJOR (1 << 20)
35d3256f88SDavid Woodhouse #define XVDBGQCV_MAJOR ((1 << 21) - 1)
36d3256f88SDavid Woodhouse #define HDA_MAJOR 3
37d3256f88SDavid Woodhouse #define HDC_MAJOR 22
38d3256f88SDavid Woodhouse #define SDA_MAJOR 8
39d3256f88SDavid Woodhouse
40d3256f88SDavid Woodhouse
vdev_to_diskno(unsigned int vdev_nr)41d3256f88SDavid Woodhouse static int vdev_to_diskno(unsigned int vdev_nr)
42d3256f88SDavid Woodhouse {
43d3256f88SDavid Woodhouse switch (vdev_nr >> 8) {
44d3256f88SDavid Woodhouse case XVDA_MAJOR:
45d3256f88SDavid Woodhouse case SDA_MAJOR:
46d3256f88SDavid Woodhouse return (vdev_nr >> 4) & 0x15;
47d3256f88SDavid Woodhouse
48d3256f88SDavid Woodhouse case HDA_MAJOR:
49d3256f88SDavid Woodhouse return (vdev_nr >> 6) & 1;
50d3256f88SDavid Woodhouse
51d3256f88SDavid Woodhouse case HDC_MAJOR:
52d3256f88SDavid Woodhouse return ((vdev_nr >> 6) & 1) + 2;
53d3256f88SDavid Woodhouse
54d3256f88SDavid Woodhouse case XVDQ_MAJOR ... XVDBGQCV_MAJOR:
55d3256f88SDavid Woodhouse return (vdev_nr >> 8) & 0xfffff;
56d3256f88SDavid Woodhouse
57d3256f88SDavid Woodhouse default:
58d3256f88SDavid Woodhouse return -1;
59d3256f88SDavid Woodhouse }
60d3256f88SDavid Woodhouse }
61d3256f88SDavid Woodhouse
62d3256f88SDavid Woodhouse #define MAX_AUTO_VDEV 4096
63d3256f88SDavid Woodhouse
64d3256f88SDavid Woodhouse /*
65d3256f88SDavid Woodhouse * Find a free device name in the xvda → xvdfan range and set it in
66d3256f88SDavid Woodhouse * blockdev->props.vdev. Our definition of "free" is that there must
67d3256f88SDavid Woodhouse * be no other disk or partition with the same disk number.
68d3256f88SDavid Woodhouse *
69d3256f88SDavid Woodhouse * You are technically permitted to have all of hda, hda1, sda, sda1,
70d3256f88SDavid Woodhouse * xvda and xvda1 as *separate* PV block devices with separate backing
71d3256f88SDavid Woodhouse * stores. That doesn't make it a good idea. This code will skip xvda
72d3256f88SDavid Woodhouse * if *any* of those "conflicting" devices already exists.
73d3256f88SDavid Woodhouse *
74d3256f88SDavid Woodhouse * The limit of xvdfan (disk 4095) is fairly arbitrary just to avoid a
75d3256f88SDavid Woodhouse * stupidly sized bitmap, but Linux as of v6.6 doesn't support anything
76d3256f88SDavid Woodhouse * higher than that anyway.
77d3256f88SDavid Woodhouse */
xen_block_find_free_vdev(XenBlockDevice * blockdev,Error ** errp)78d3256f88SDavid Woodhouse static bool xen_block_find_free_vdev(XenBlockDevice *blockdev, Error **errp)
79d3256f88SDavid Woodhouse {
80d3256f88SDavid Woodhouse XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(blockdev)));
81d3256f88SDavid Woodhouse unsigned long used_devs[BITS_TO_LONGS(MAX_AUTO_VDEV)];
82d3256f88SDavid Woodhouse XenBlockVdev *vdev = &blockdev->props.vdev;
83d3256f88SDavid Woodhouse char fe_path[XENSTORE_ABS_PATH_MAX + 1];
84d3256f88SDavid Woodhouse char **existing_frontends;
85d3256f88SDavid Woodhouse unsigned int nr_existing = 0;
86d3256f88SDavid Woodhouse unsigned int vdev_nr;
87d3256f88SDavid Woodhouse int i, disk = 0;
88d3256f88SDavid Woodhouse
89d3256f88SDavid Woodhouse snprintf(fe_path, sizeof(fe_path), "/local/domain/%u/device/vbd",
90d3256f88SDavid Woodhouse blockdev->xendev.frontend_id);
91d3256f88SDavid Woodhouse
92d3256f88SDavid Woodhouse existing_frontends = qemu_xen_xs_directory(xenbus->xsh, XBT_NULL, fe_path,
93d3256f88SDavid Woodhouse &nr_existing);
94*6f7997e0SDavid Woodhouse if (!existing_frontends) {
95*6f7997e0SDavid Woodhouse if (errno == ENOENT) {
96*6f7997e0SDavid Woodhouse /*
97*6f7997e0SDavid Woodhouse * If the frontend directory doesn't exist because there are
98*6f7997e0SDavid Woodhouse * no existing vbd devices, that's fine. Just ensure that we
99*6f7997e0SDavid Woodhouse * don't dereference the NULL existing_frontends pointer, by
100*6f7997e0SDavid Woodhouse * checking that nr_existing is zero so the loop below is not
101*6f7997e0SDavid Woodhouse * entered.
102*6f7997e0SDavid Woodhouse *
103*6f7997e0SDavid Woodhouse * In fact this is redundant since nr_existing is initialized
104*6f7997e0SDavid Woodhouse * to zero, but setting it again here makes it abundantly clear
105*6f7997e0SDavid Woodhouse * to Coverity, and to the human reader who doesn't know the
106*6f7997e0SDavid Woodhouse * semantics of qemu_xen_xs_directory() off the top of their
107*6f7997e0SDavid Woodhouse * head.
108*6f7997e0SDavid Woodhouse */
109*6f7997e0SDavid Woodhouse nr_existing = 0;
110*6f7997e0SDavid Woodhouse } else {
111*6f7997e0SDavid Woodhouse /* All other errors accessing the frontend directory are fatal. */
112d3256f88SDavid Woodhouse error_setg_errno(errp, errno, "cannot read %s", fe_path);
113d3256f88SDavid Woodhouse return false;
114d3256f88SDavid Woodhouse }
115*6f7997e0SDavid Woodhouse }
116d3256f88SDavid Woodhouse
117d3256f88SDavid Woodhouse memset(used_devs, 0, sizeof(used_devs));
118d3256f88SDavid Woodhouse for (i = 0; i < nr_existing; i++) {
119d3256f88SDavid Woodhouse if (qemu_strtoui(existing_frontends[i], NULL, 10, &vdev_nr)) {
120d3256f88SDavid Woodhouse free(existing_frontends[i]);
121d3256f88SDavid Woodhouse continue;
122d3256f88SDavid Woodhouse }
123d3256f88SDavid Woodhouse
124d3256f88SDavid Woodhouse free(existing_frontends[i]);
125d3256f88SDavid Woodhouse
126d3256f88SDavid Woodhouse disk = vdev_to_diskno(vdev_nr);
127d3256f88SDavid Woodhouse if (disk < 0 || disk >= MAX_AUTO_VDEV) {
128d3256f88SDavid Woodhouse continue;
129d3256f88SDavid Woodhouse }
130d3256f88SDavid Woodhouse
131d3256f88SDavid Woodhouse set_bit(disk, used_devs);
132d3256f88SDavid Woodhouse }
133d3256f88SDavid Woodhouse free(existing_frontends);
134d3256f88SDavid Woodhouse
135d3256f88SDavid Woodhouse disk = find_first_zero_bit(used_devs, MAX_AUTO_VDEV);
136d3256f88SDavid Woodhouse if (disk == MAX_AUTO_VDEV) {
137d3256f88SDavid Woodhouse error_setg(errp, "cannot find device vdev for block device");
138d3256f88SDavid Woodhouse return false;
139d3256f88SDavid Woodhouse }
140d3256f88SDavid Woodhouse
141d3256f88SDavid Woodhouse vdev->type = XEN_BLOCK_VDEV_TYPE_XVD;
142d3256f88SDavid Woodhouse vdev->partition = 0;
143d3256f88SDavid Woodhouse vdev->disk = disk;
144d3256f88SDavid Woodhouse if (disk < (1 << 4)) {
145d3256f88SDavid Woodhouse vdev->number = (XVDA_MAJOR << 8) | (disk << 4);
146d3256f88SDavid Woodhouse } else {
147d3256f88SDavid Woodhouse vdev->number = (XVDQ_MAJOR << 8) | (disk << 8);
148d3256f88SDavid Woodhouse }
149d3256f88SDavid Woodhouse return true;
150d3256f88SDavid Woodhouse }
151d3256f88SDavid Woodhouse
xen_block_get_name(XenDevice * xendev,Error ** errp)152094a2239SPaul Durrant static char *xen_block_get_name(XenDevice *xendev, Error **errp)
153094a2239SPaul Durrant {
154094a2239SPaul Durrant XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
155094a2239SPaul Durrant XenBlockVdev *vdev = &blockdev->props.vdev;
156094a2239SPaul Durrant
157d3256f88SDavid Woodhouse if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID &&
158d3256f88SDavid Woodhouse !xen_block_find_free_vdev(blockdev, errp)) {
159d3256f88SDavid Woodhouse return NULL;
160d3256f88SDavid Woodhouse }
161094a2239SPaul Durrant return g_strdup_printf("%lu", vdev->number);
162094a2239SPaul Durrant }
163094a2239SPaul Durrant
xen_block_disconnect(XenDevice * xendev,Error ** errp)16482a29e30SPaul Durrant static void xen_block_disconnect(XenDevice *xendev, Error **errp)
16582a29e30SPaul Durrant {
16682a29e30SPaul Durrant XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
16782a29e30SPaul Durrant const char *type = object_get_typename(OBJECT(blockdev));
16882a29e30SPaul Durrant XenBlockVdev *vdev = &blockdev->props.vdev;
16982a29e30SPaul Durrant
17082a29e30SPaul Durrant trace_xen_block_disconnect(type, vdev->disk, vdev->partition);
171b6af8926SPaul Durrant
172b6af8926SPaul Durrant xen_block_dataplane_stop(blockdev->dataplane);
17382a29e30SPaul Durrant }
17482a29e30SPaul Durrant
xen_block_connect(XenDevice * xendev,Error ** errp)17582a29e30SPaul Durrant static void xen_block_connect(XenDevice *xendev, Error **errp)
17682a29e30SPaul Durrant {
17782a29e30SPaul Durrant XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
17882a29e30SPaul Durrant const char *type = object_get_typename(OBJECT(blockdev));
17982a29e30SPaul Durrant XenBlockVdev *vdev = &blockdev->props.vdev;
1805feeb718SPaul Durrant BlockConf *conf = &blockdev->props.conf;
1815feeb718SPaul Durrant unsigned int feature_large_sector_size;
182b6af8926SPaul Durrant unsigned int order, nr_ring_ref, *ring_ref, event_channel, protocol;
183b6af8926SPaul Durrant char *str;
18482a29e30SPaul Durrant
18582a29e30SPaul Durrant trace_xen_block_connect(type, vdev->disk, vdev->partition);
186b6af8926SPaul Durrant
1875feeb718SPaul Durrant if (xen_device_frontend_scanf(xendev, "feature-large-sector-size", "%u",
1885feeb718SPaul Durrant &feature_large_sector_size) != 1) {
1895feeb718SPaul Durrant feature_large_sector_size = 0;
1905feeb718SPaul Durrant }
1915feeb718SPaul Durrant
1925feeb718SPaul Durrant if (feature_large_sector_size != 1 &&
1935feeb718SPaul Durrant conf->logical_block_size != XEN_BLKIF_SECTOR_SIZE) {
1945feeb718SPaul Durrant error_setg(errp, "logical_block_size != %u not supported by frontend",
1955feeb718SPaul Durrant XEN_BLKIF_SECTOR_SIZE);
1965feeb718SPaul Durrant return;
1975feeb718SPaul Durrant }
1985feeb718SPaul Durrant
199b6af8926SPaul Durrant if (xen_device_frontend_scanf(xendev, "ring-page-order", "%u",
200b6af8926SPaul Durrant &order) != 1) {
201b6af8926SPaul Durrant nr_ring_ref = 1;
202b6af8926SPaul Durrant ring_ref = g_new(unsigned int, nr_ring_ref);
203b6af8926SPaul Durrant
204b6af8926SPaul Durrant if (xen_device_frontend_scanf(xendev, "ring-ref", "%u",
205b6af8926SPaul Durrant &ring_ref[0]) != 1) {
206b6af8926SPaul Durrant error_setg(errp, "failed to read ring-ref");
207b6af8926SPaul Durrant g_free(ring_ref);
208b6af8926SPaul Durrant return;
209b6af8926SPaul Durrant }
21007251903SDavid Woodhouse } else if (qemu_xen_gnttab_can_map_multi() &&
21107251903SDavid Woodhouse order <= blockdev->props.max_ring_page_order) {
212b6af8926SPaul Durrant unsigned int i;
213b6af8926SPaul Durrant
214b6af8926SPaul Durrant nr_ring_ref = 1 << order;
215b6af8926SPaul Durrant ring_ref = g_new(unsigned int, nr_ring_ref);
216b6af8926SPaul Durrant
217b6af8926SPaul Durrant for (i = 0; i < nr_ring_ref; i++) {
218b6af8926SPaul Durrant const char *key = g_strdup_printf("ring-ref%u", i);
219b6af8926SPaul Durrant
220b6af8926SPaul Durrant if (xen_device_frontend_scanf(xendev, key, "%u",
221b6af8926SPaul Durrant &ring_ref[i]) != 1) {
222b6af8926SPaul Durrant error_setg(errp, "failed to read %s", key);
223b6af8926SPaul Durrant g_free((gpointer)key);
224b6af8926SPaul Durrant g_free(ring_ref);
225b6af8926SPaul Durrant return;
226b6af8926SPaul Durrant }
227b6af8926SPaul Durrant
228b6af8926SPaul Durrant g_free((gpointer)key);
229b6af8926SPaul Durrant }
230b6af8926SPaul Durrant } else {
231b6af8926SPaul Durrant error_setg(errp, "invalid ring-page-order (%d)", order);
232b6af8926SPaul Durrant return;
233b6af8926SPaul Durrant }
234b6af8926SPaul Durrant
235b6af8926SPaul Durrant if (xen_device_frontend_scanf(xendev, "event-channel", "%u",
236b6af8926SPaul Durrant &event_channel) != 1) {
237b6af8926SPaul Durrant error_setg(errp, "failed to read event-channel");
238b6af8926SPaul Durrant g_free(ring_ref);
239b6af8926SPaul Durrant return;
240b6af8926SPaul Durrant }
241b6af8926SPaul Durrant
242a1c10829SDavid Woodhouse if (xen_device_frontend_scanf(xendev, "protocol", "%ms", &str) != 1) {
243a1c10829SDavid Woodhouse /* x86 defaults to the 32-bit protocol even for 64-bit guests. */
244a1c10829SDavid Woodhouse if (object_dynamic_cast(OBJECT(qdev_get_machine()), "x86-machine")) {
245a1c10829SDavid Woodhouse protocol = BLKIF_PROTOCOL_X86_32;
246a1c10829SDavid Woodhouse } else {
247b6af8926SPaul Durrant protocol = BLKIF_PROTOCOL_NATIVE;
248a1c10829SDavid Woodhouse }
249b6af8926SPaul Durrant } else {
250b6af8926SPaul Durrant if (strcmp(str, XEN_IO_PROTO_ABI_X86_32) == 0) {
251b6af8926SPaul Durrant protocol = BLKIF_PROTOCOL_X86_32;
252b6af8926SPaul Durrant } else if (strcmp(str, XEN_IO_PROTO_ABI_X86_64) == 0) {
253b6af8926SPaul Durrant protocol = BLKIF_PROTOCOL_X86_64;
254b6af8926SPaul Durrant } else {
255b6af8926SPaul Durrant protocol = BLKIF_PROTOCOL_NATIVE;
256b6af8926SPaul Durrant }
257b6af8926SPaul Durrant
258b6af8926SPaul Durrant free(str);
259b6af8926SPaul Durrant }
260b6af8926SPaul Durrant
261b6af8926SPaul Durrant xen_block_dataplane_start(blockdev->dataplane, ring_ref, nr_ring_ref,
262b6af8926SPaul Durrant event_channel, protocol, errp);
263b6af8926SPaul Durrant
264b6af8926SPaul Durrant g_free(ring_ref);
26582a29e30SPaul Durrant }
26682a29e30SPaul Durrant
xen_block_unrealize(XenDevice * xendev)267b69c3c21SMarkus Armbruster static void xen_block_unrealize(XenDevice *xendev)
2681a72d9aeSPaul Durrant {
2691a72d9aeSPaul Durrant XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
2701a72d9aeSPaul Durrant XenBlockDeviceClass *blockdev_class =
2711a72d9aeSPaul Durrant XEN_BLOCK_DEVICE_GET_CLASS(xendev);
2721a72d9aeSPaul Durrant const char *type = object_get_typename(OBJECT(blockdev));
2731a72d9aeSPaul Durrant XenBlockVdev *vdev = &blockdev->props.vdev;
2741a72d9aeSPaul Durrant
2751a72d9aeSPaul Durrant if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) {
2761a72d9aeSPaul Durrant return;
2771a72d9aeSPaul Durrant }
2781a72d9aeSPaul Durrant
2791a72d9aeSPaul Durrant trace_xen_block_unrealize(type, vdev->disk, vdev->partition);
2801a72d9aeSPaul Durrant
28182a29e30SPaul Durrant /* Disconnect from the frontend in case this has not already happened */
28282a29e30SPaul Durrant xen_block_disconnect(xendev, NULL);
28382a29e30SPaul Durrant
284b6af8926SPaul Durrant xen_block_dataplane_destroy(blockdev->dataplane);
285b6af8926SPaul Durrant blockdev->dataplane = NULL;
286b6af8926SPaul Durrant
2871a72d9aeSPaul Durrant if (blockdev_class->unrealize) {
288b69c3c21SMarkus Armbruster blockdev_class->unrealize(blockdev);
2891a72d9aeSPaul Durrant }
2901a72d9aeSPaul Durrant }
2911a72d9aeSPaul Durrant
xen_block_set_size(XenBlockDevice * blockdev)2923149f183SPaul Durrant static void xen_block_set_size(XenBlockDevice *blockdev)
2933149f183SPaul Durrant {
2943149f183SPaul Durrant const char *type = object_get_typename(OBJECT(blockdev));
2953149f183SPaul Durrant XenBlockVdev *vdev = &blockdev->props.vdev;
2963149f183SPaul Durrant BlockConf *conf = &blockdev->props.conf;
2975feeb718SPaul Durrant int64_t sectors = blk_getlength(conf->blk) / conf->logical_block_size;
2983149f183SPaul Durrant XenDevice *xendev = XEN_DEVICE(blockdev);
2993149f183SPaul Durrant
3003149f183SPaul Durrant trace_xen_block_size(type, vdev->disk, vdev->partition, sectors);
3013149f183SPaul Durrant
3023149f183SPaul Durrant xen_device_backend_printf(xendev, "sectors", "%"PRIi64, sectors);
3033149f183SPaul Durrant }
3043149f183SPaul Durrant
xen_block_resize_cb(void * opaque)3053149f183SPaul Durrant static void xen_block_resize_cb(void *opaque)
3063149f183SPaul Durrant {
3073149f183SPaul Durrant XenBlockDevice *blockdev = opaque;
3083149f183SPaul Durrant XenDevice *xendev = XEN_DEVICE(blockdev);
3093149f183SPaul Durrant enum xenbus_state state = xen_device_backend_get_state(xendev);
3103149f183SPaul Durrant
3113149f183SPaul Durrant xen_block_set_size(blockdev);
3123149f183SPaul Durrant
3133149f183SPaul Durrant /*
3143149f183SPaul Durrant * Mimic the behaviour of Linux xen-blkback and re-write the state
3153149f183SPaul Durrant * to trigger the frontend watch.
3163149f183SPaul Durrant */
3173149f183SPaul Durrant xen_device_backend_printf(xendev, "state", "%u", state);
3183149f183SPaul Durrant }
3193149f183SPaul Durrant
320f6eac904SStefan Hajnoczi /* Suspend request handling */
xen_block_drained_begin(void * opaque)321f6eac904SStefan Hajnoczi static void xen_block_drained_begin(void *opaque)
322f6eac904SStefan Hajnoczi {
323f6eac904SStefan Hajnoczi XenBlockDevice *blockdev = opaque;
324f6eac904SStefan Hajnoczi
325f6eac904SStefan Hajnoczi xen_block_dataplane_detach(blockdev->dataplane);
326f6eac904SStefan Hajnoczi }
327f6eac904SStefan Hajnoczi
328f6eac904SStefan Hajnoczi /* Resume request handling */
xen_block_drained_end(void * opaque)329f6eac904SStefan Hajnoczi static void xen_block_drained_end(void *opaque)
330f6eac904SStefan Hajnoczi {
331f6eac904SStefan Hajnoczi XenBlockDevice *blockdev = opaque;
332f6eac904SStefan Hajnoczi
333f6eac904SStefan Hajnoczi xen_block_dataplane_attach(blockdev->dataplane);
334f6eac904SStefan Hajnoczi }
335f6eac904SStefan Hajnoczi
3363149f183SPaul Durrant static const BlockDevOps xen_block_dev_ops = {
3373149f183SPaul Durrant .resize_cb = xen_block_resize_cb,
338f6eac904SStefan Hajnoczi .drained_begin = xen_block_drained_begin,
339f6eac904SStefan Hajnoczi .drained_end = xen_block_drained_end,
3403149f183SPaul Durrant };
3413149f183SPaul Durrant
xen_block_realize(XenDevice * xendev,Error ** errp)3421a72d9aeSPaul Durrant static void xen_block_realize(XenDevice *xendev, Error **errp)
3431a72d9aeSPaul Durrant {
3441de7096dSVladimir Sementsov-Ogievskiy ERRP_GUARD();
3451a72d9aeSPaul Durrant XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
3461a72d9aeSPaul Durrant XenBlockDeviceClass *blockdev_class =
3471a72d9aeSPaul Durrant XEN_BLOCK_DEVICE_GET_CLASS(xendev);
3481a72d9aeSPaul Durrant const char *type = object_get_typename(OBJECT(blockdev));
3491a72d9aeSPaul Durrant XenBlockVdev *vdev = &blockdev->props.vdev;
350b6af8926SPaul Durrant BlockConf *conf = &blockdev->props.conf;
3515feeb718SPaul Durrant BlockBackend *blk = conf->blk;
3521a72d9aeSPaul Durrant
3531a72d9aeSPaul Durrant if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) {
3541a72d9aeSPaul Durrant error_setg(errp, "vdev property not set");
3551a72d9aeSPaul Durrant return;
3561a72d9aeSPaul Durrant }
3571a72d9aeSPaul Durrant
3581a72d9aeSPaul Durrant trace_xen_block_realize(type, vdev->disk, vdev->partition);
3591a72d9aeSPaul Durrant
3601a72d9aeSPaul Durrant if (blockdev_class->realize) {
3611de7096dSVladimir Sementsov-Ogievskiy blockdev_class->realize(blockdev, errp);
3621de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
363b6af8926SPaul Durrant return;
3641a72d9aeSPaul Durrant }
3651a72d9aeSPaul Durrant }
366b6af8926SPaul Durrant
367b6af8926SPaul Durrant /*
368b6af8926SPaul Durrant * The blkif protocol does not deal with removable media, so it must
369b6af8926SPaul Durrant * always be present, even for CDRom devices.
370b6af8926SPaul Durrant */
3715feeb718SPaul Durrant assert(blk);
3725feeb718SPaul Durrant if (!blk_is_inserted(blk)) {
373b6af8926SPaul Durrant error_setg(errp, "device needs media, but drive is empty");
374b6af8926SPaul Durrant return;
375b6af8926SPaul Durrant }
376b6af8926SPaul Durrant
377b6af8926SPaul Durrant if (!blkconf_apply_backend_options(conf, blockdev->info & VDISK_READONLY,
3783149f183SPaul Durrant true, errp)) {
379b6af8926SPaul Durrant return;
380b6af8926SPaul Durrant }
381b6af8926SPaul Durrant
382b6af8926SPaul Durrant if (!(blockdev->info & VDISK_CDROM) &&
383b6af8926SPaul Durrant !blkconf_geometry(conf, NULL, 65535, 255, 255, errp)) {
384b6af8926SPaul Durrant return;
385b6af8926SPaul Durrant }
386b6af8926SPaul Durrant
387c56ee92fSRoman Kagan if (!blkconf_blocksizes(conf, errp)) {
388b6af8926SPaul Durrant return;
389b6af8926SPaul Durrant }
390b6af8926SPaul Durrant
39115f08450SPaul Durrant if (conf->discard_granularity == -1) {
39215f08450SPaul Durrant conf->discard_granularity = conf->physical_block_size;
39315f08450SPaul Durrant }
39415f08450SPaul Durrant
3955feeb718SPaul Durrant if (blk_get_flags(blk) & BDRV_O_UNMAP) {
396b6af8926SPaul Durrant xen_device_backend_printf(xendev, "feature-discard", "%u", 1);
39715f08450SPaul Durrant xen_device_backend_printf(xendev, "discard-granularity", "%u",
39815f08450SPaul Durrant conf->discard_granularity);
3997f22201aSRoger Pau Monne xen_device_backend_printf(xendev, "discard-alignment", "%u", 0);
400b6af8926SPaul Durrant }
401b6af8926SPaul Durrant
402b6af8926SPaul Durrant xen_device_backend_printf(xendev, "feature-flush-cache", "%u", 1);
40307251903SDavid Woodhouse
40407251903SDavid Woodhouse if (qemu_xen_gnttab_can_map_multi()) {
405b6af8926SPaul Durrant xen_device_backend_printf(xendev, "max-ring-page-order", "%u",
406b6af8926SPaul Durrant blockdev->props.max_ring_page_order);
40707251903SDavid Woodhouse }
40807251903SDavid Woodhouse
409b6af8926SPaul Durrant xen_device_backend_printf(xendev, "info", "%u", blockdev->info);
410b6af8926SPaul Durrant
411b6af8926SPaul Durrant xen_device_frontend_printf(xendev, "virtual-device", "%lu",
412b6af8926SPaul Durrant vdev->number);
413b6af8926SPaul Durrant xen_device_frontend_printf(xendev, "device-type", "%s",
414b6af8926SPaul Durrant blockdev->device_type);
415b6af8926SPaul Durrant
416b6af8926SPaul Durrant xen_device_backend_printf(xendev, "sector-size", "%u",
4175feeb718SPaul Durrant conf->logical_block_size);
4183149f183SPaul Durrant
4193149f183SPaul Durrant xen_block_set_size(blockdev);
420b6af8926SPaul Durrant
421b6af8926SPaul Durrant blockdev->dataplane =
4225feeb718SPaul Durrant xen_block_dataplane_create(xendev, blk, conf->logical_block_size,
4235feeb718SPaul Durrant blockdev->props.iothread);
424f6eac904SStefan Hajnoczi
425f6eac904SStefan Hajnoczi blk_set_dev_ops(blk, &xen_block_dev_ops, blockdev);
4261a72d9aeSPaul Durrant }
4271a72d9aeSPaul Durrant
xen_block_frontend_changed(XenDevice * xendev,enum xenbus_state frontend_state,Error ** errp)42882a29e30SPaul Durrant static void xen_block_frontend_changed(XenDevice *xendev,
42982a29e30SPaul Durrant enum xenbus_state frontend_state,
43082a29e30SPaul Durrant Error **errp)
43182a29e30SPaul Durrant {
4321de7096dSVladimir Sementsov-Ogievskiy ERRP_GUARD();
43382a29e30SPaul Durrant enum xenbus_state backend_state = xen_device_backend_get_state(xendev);
43482a29e30SPaul Durrant
43582a29e30SPaul Durrant switch (frontend_state) {
43682a29e30SPaul Durrant case XenbusStateInitialised:
43782a29e30SPaul Durrant case XenbusStateConnected:
43882a29e30SPaul Durrant if (backend_state == XenbusStateConnected) {
43982a29e30SPaul Durrant break;
44082a29e30SPaul Durrant }
44182a29e30SPaul Durrant
4421de7096dSVladimir Sementsov-Ogievskiy xen_block_disconnect(xendev, errp);
4431de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
44482a29e30SPaul Durrant break;
44582a29e30SPaul Durrant }
44682a29e30SPaul Durrant
4471de7096dSVladimir Sementsov-Ogievskiy xen_block_connect(xendev, errp);
4481de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
44982a29e30SPaul Durrant break;
45082a29e30SPaul Durrant }
45182a29e30SPaul Durrant
45282a29e30SPaul Durrant xen_device_backend_set_state(xendev, XenbusStateConnected);
45382a29e30SPaul Durrant break;
45482a29e30SPaul Durrant
45582a29e30SPaul Durrant case XenbusStateClosing:
45682a29e30SPaul Durrant xen_device_backend_set_state(xendev, XenbusStateClosing);
45782a29e30SPaul Durrant break;
45882a29e30SPaul Durrant
45982a29e30SPaul Durrant case XenbusStateClosed:
460ef916ab3SPaul Durrant case XenbusStateUnknown:
4611de7096dSVladimir Sementsov-Ogievskiy xen_block_disconnect(xendev, errp);
4621de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
46382a29e30SPaul Durrant break;
46482a29e30SPaul Durrant }
46582a29e30SPaul Durrant
46682a29e30SPaul Durrant xen_device_backend_set_state(xendev, XenbusStateClosed);
46782a29e30SPaul Durrant break;
46882a29e30SPaul Durrant
46982a29e30SPaul Durrant default:
47082a29e30SPaul Durrant break;
47182a29e30SPaul Durrant }
47282a29e30SPaul Durrant }
47382a29e30SPaul Durrant
disk_to_vbd_name(unsigned int disk)4741a72d9aeSPaul Durrant static char *disk_to_vbd_name(unsigned int disk)
4751a72d9aeSPaul Durrant {
4761a72d9aeSPaul Durrant char *name, *prefix = (disk >= 26) ?
4771a72d9aeSPaul Durrant disk_to_vbd_name((disk / 26) - 1) : g_strdup("");
4781a72d9aeSPaul Durrant
4791a72d9aeSPaul Durrant name = g_strdup_printf("%s%c", prefix, 'a' + disk % 26);
4801a72d9aeSPaul Durrant g_free(prefix);
4811a72d9aeSPaul Durrant
4821a72d9aeSPaul Durrant return name;
4831a72d9aeSPaul Durrant }
4841a72d9aeSPaul Durrant
xen_block_get_vdev(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)4851a72d9aeSPaul Durrant static void xen_block_get_vdev(Object *obj, Visitor *v, const char *name,
4861a72d9aeSPaul Durrant void *opaque, Error **errp)
4871a72d9aeSPaul Durrant {
4881a72d9aeSPaul Durrant Property *prop = opaque;
4891e198715SEduardo Habkost XenBlockVdev *vdev = object_field_prop_ptr(obj, prop);
4901a72d9aeSPaul Durrant char *str;
4911a72d9aeSPaul Durrant
4921a72d9aeSPaul Durrant switch (vdev->type) {
4931a72d9aeSPaul Durrant case XEN_BLOCK_VDEV_TYPE_DP:
4941a72d9aeSPaul Durrant str = g_strdup_printf("d%lup%lu", vdev->disk, vdev->partition);
4951a72d9aeSPaul Durrant break;
4961a72d9aeSPaul Durrant
4971a72d9aeSPaul Durrant case XEN_BLOCK_VDEV_TYPE_XVD:
4981a72d9aeSPaul Durrant case XEN_BLOCK_VDEV_TYPE_HD:
4991a72d9aeSPaul Durrant case XEN_BLOCK_VDEV_TYPE_SD: {
500fb2575f9SMarkus Armbruster char *vbd_name = disk_to_vbd_name(vdev->disk);
5011a72d9aeSPaul Durrant
5021a72d9aeSPaul Durrant str = g_strdup_printf("%s%s%lu",
5031a72d9aeSPaul Durrant (vdev->type == XEN_BLOCK_VDEV_TYPE_XVD) ?
5041a72d9aeSPaul Durrant "xvd" :
5051a72d9aeSPaul Durrant (vdev->type == XEN_BLOCK_VDEV_TYPE_HD) ?
5061a72d9aeSPaul Durrant "hd" :
5071a72d9aeSPaul Durrant "sd",
508fb2575f9SMarkus Armbruster vbd_name, vdev->partition);
509fb2575f9SMarkus Armbruster g_free(vbd_name);
5101a72d9aeSPaul Durrant break;
5111a72d9aeSPaul Durrant }
5121a72d9aeSPaul Durrant default:
5131a72d9aeSPaul Durrant error_setg(errp, "invalid vdev type");
5141a72d9aeSPaul Durrant return;
5151a72d9aeSPaul Durrant }
5161a72d9aeSPaul Durrant
5171a72d9aeSPaul Durrant visit_type_str(v, name, &str, errp);
5181a72d9aeSPaul Durrant g_free(str);
5191a72d9aeSPaul Durrant }
5201a72d9aeSPaul Durrant
vbd_name_to_disk(const char * name,const char ** endp,unsigned long * disk)5212ae23f0eSPaul Durrant static int vbd_name_to_disk(const char *name, const char **endp,
5222ae23f0eSPaul Durrant unsigned long *disk)
5231a72d9aeSPaul Durrant {
5242ae23f0eSPaul Durrant unsigned int n = 0;
5251a72d9aeSPaul Durrant
5261a72d9aeSPaul Durrant while (*name != '\0') {
5271a72d9aeSPaul Durrant if (!g_ascii_isalpha(*name) || !g_ascii_islower(*name)) {
5281a72d9aeSPaul Durrant break;
5291a72d9aeSPaul Durrant }
5301a72d9aeSPaul Durrant
5312ae23f0eSPaul Durrant n *= 26;
5322ae23f0eSPaul Durrant n += *name++ - 'a' + 1;
5331a72d9aeSPaul Durrant }
5341a72d9aeSPaul Durrant *endp = name;
5351a72d9aeSPaul Durrant
5362ae23f0eSPaul Durrant if (!n) {
5372ae23f0eSPaul Durrant return -1;
5382ae23f0eSPaul Durrant }
5392ae23f0eSPaul Durrant
5402ae23f0eSPaul Durrant *disk = n - 1;
5412ae23f0eSPaul Durrant
5422ae23f0eSPaul Durrant return 0;
5431a72d9aeSPaul Durrant }
5441a72d9aeSPaul Durrant
xen_block_set_vdev(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)5451a72d9aeSPaul Durrant static void xen_block_set_vdev(Object *obj, Visitor *v, const char *name,
5461a72d9aeSPaul Durrant void *opaque, Error **errp)
5471a72d9aeSPaul Durrant {
5481a72d9aeSPaul Durrant Property *prop = opaque;
5491e198715SEduardo Habkost XenBlockVdev *vdev = object_field_prop_ptr(obj, prop);
5501a72d9aeSPaul Durrant char *str, *p;
5511a72d9aeSPaul Durrant const char *end;
5521a72d9aeSPaul Durrant
553668f62ecSMarkus Armbruster if (!visit_type_str(v, name, &str, errp)) {
5541a72d9aeSPaul Durrant return;
5551a72d9aeSPaul Durrant }
5561a72d9aeSPaul Durrant
5571a72d9aeSPaul Durrant p = strchr(str, 'd');
5581a72d9aeSPaul Durrant if (!p) {
5591a72d9aeSPaul Durrant goto invalid;
5601a72d9aeSPaul Durrant }
5611a72d9aeSPaul Durrant
5621a72d9aeSPaul Durrant *p++ = '\0';
5631a72d9aeSPaul Durrant if (*str == '\0') {
5641a72d9aeSPaul Durrant vdev->type = XEN_BLOCK_VDEV_TYPE_DP;
5651a72d9aeSPaul Durrant } else if (strcmp(str, "xv") == 0) {
5661a72d9aeSPaul Durrant vdev->type = XEN_BLOCK_VDEV_TYPE_XVD;
5671a72d9aeSPaul Durrant } else if (strcmp(str, "h") == 0) {
5681a72d9aeSPaul Durrant vdev->type = XEN_BLOCK_VDEV_TYPE_HD;
5691a72d9aeSPaul Durrant } else if (strcmp(str, "s") == 0) {
5701a72d9aeSPaul Durrant vdev->type = XEN_BLOCK_VDEV_TYPE_SD;
5711a72d9aeSPaul Durrant } else {
5721a72d9aeSPaul Durrant goto invalid;
5731a72d9aeSPaul Durrant }
5741a72d9aeSPaul Durrant
5751a72d9aeSPaul Durrant if (vdev->type == XEN_BLOCK_VDEV_TYPE_DP) {
5761a72d9aeSPaul Durrant if (qemu_strtoul(p, &end, 10, &vdev->disk)) {
5771a72d9aeSPaul Durrant goto invalid;
5781a72d9aeSPaul Durrant }
5791a72d9aeSPaul Durrant
5801a72d9aeSPaul Durrant if (*end == 'p') {
581210b9776SPaul Durrant if (*(++end) == '\0') {
5821a72d9aeSPaul Durrant goto invalid;
5831a72d9aeSPaul Durrant }
5841a72d9aeSPaul Durrant }
5851a72d9aeSPaul Durrant } else {
5862ae23f0eSPaul Durrant if (vbd_name_to_disk(p, &end, &vdev->disk)) {
5872ae23f0eSPaul Durrant goto invalid;
5882ae23f0eSPaul Durrant }
5891a72d9aeSPaul Durrant }
5901a72d9aeSPaul Durrant
5911a72d9aeSPaul Durrant if (*end != '\0') {
5921a72d9aeSPaul Durrant p = (char *)end;
5931a72d9aeSPaul Durrant
5941a72d9aeSPaul Durrant if (qemu_strtoul(p, &end, 10, &vdev->partition)) {
5951a72d9aeSPaul Durrant goto invalid;
5961a72d9aeSPaul Durrant }
5971a72d9aeSPaul Durrant
5981a72d9aeSPaul Durrant if (*end != '\0') {
5991a72d9aeSPaul Durrant goto invalid;
6001a72d9aeSPaul Durrant }
6011a72d9aeSPaul Durrant } else {
6021a72d9aeSPaul Durrant vdev->partition = 0;
6031a72d9aeSPaul Durrant }
6041a72d9aeSPaul Durrant
6051a72d9aeSPaul Durrant switch (vdev->type) {
6061a72d9aeSPaul Durrant case XEN_BLOCK_VDEV_TYPE_DP:
6071a72d9aeSPaul Durrant case XEN_BLOCK_VDEV_TYPE_XVD:
6081a72d9aeSPaul Durrant if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) {
609d3256f88SDavid Woodhouse vdev->number = (XVDA_MAJOR << 8) | (vdev->disk << 4) |
6101a72d9aeSPaul Durrant vdev->partition;
6111a72d9aeSPaul Durrant } else if (vdev->disk < (1 << 20) && vdev->partition < (1 << 8)) {
612d3256f88SDavid Woodhouse vdev->number = (XVDQ_MAJOR << 8) | (vdev->disk << 8) |
6131a72d9aeSPaul Durrant vdev->partition;
6141a72d9aeSPaul Durrant } else {
6151a72d9aeSPaul Durrant goto invalid;
6161a72d9aeSPaul Durrant }
6171a72d9aeSPaul Durrant break;
6181a72d9aeSPaul Durrant
6191a72d9aeSPaul Durrant case XEN_BLOCK_VDEV_TYPE_HD:
6201a72d9aeSPaul Durrant if ((vdev->disk == 0 || vdev->disk == 1) &&
6211a72d9aeSPaul Durrant vdev->partition < (1 << 6)) {
622d3256f88SDavid Woodhouse vdev->number = (HDA_MAJOR << 8) | (vdev->disk << 6) |
623d3256f88SDavid Woodhouse vdev->partition;
6241a72d9aeSPaul Durrant } else if ((vdev->disk == 2 || vdev->disk == 3) &&
6251a72d9aeSPaul Durrant vdev->partition < (1 << 6)) {
626d3256f88SDavid Woodhouse vdev->number = (HDC_MAJOR << 8) | ((vdev->disk - 2) << 6) |
6271a72d9aeSPaul Durrant vdev->partition;
6281a72d9aeSPaul Durrant } else {
6291a72d9aeSPaul Durrant goto invalid;
6301a72d9aeSPaul Durrant }
6311a72d9aeSPaul Durrant break;
6321a72d9aeSPaul Durrant
6331a72d9aeSPaul Durrant case XEN_BLOCK_VDEV_TYPE_SD:
6341a72d9aeSPaul Durrant if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) {
635d3256f88SDavid Woodhouse vdev->number = (SDA_MAJOR << 8) | (vdev->disk << 4) |
636d3256f88SDavid Woodhouse vdev->partition;
6371a72d9aeSPaul Durrant } else {
6381a72d9aeSPaul Durrant goto invalid;
6391a72d9aeSPaul Durrant }
6401a72d9aeSPaul Durrant break;
6411a72d9aeSPaul Durrant
6421a72d9aeSPaul Durrant default:
6431a72d9aeSPaul Durrant goto invalid;
6441a72d9aeSPaul Durrant }
6451a72d9aeSPaul Durrant
6461a72d9aeSPaul Durrant g_free(str);
6471a72d9aeSPaul Durrant return;
6481a72d9aeSPaul Durrant
6491a72d9aeSPaul Durrant invalid:
6501a72d9aeSPaul Durrant error_setg(errp, "invalid virtual disk specifier");
6511a72d9aeSPaul Durrant
6521a72d9aeSPaul Durrant vdev->type = XEN_BLOCK_VDEV_TYPE_INVALID;
6531a72d9aeSPaul Durrant g_free(str);
6541a72d9aeSPaul Durrant }
6551a72d9aeSPaul Durrant
6561a72d9aeSPaul Durrant /*
6571a72d9aeSPaul Durrant * This property deals with 'vdev' names adhering to the Xen VBD naming
6581a72d9aeSPaul Durrant * scheme described in:
6591a72d9aeSPaul Durrant *
6601a72d9aeSPaul Durrant * https://xenbits.xen.org/docs/unstable/man/xen-vbd-interface.7.html
6611a72d9aeSPaul Durrant */
6621a72d9aeSPaul Durrant const PropertyInfo xen_block_prop_vdev = {
6631a72d9aeSPaul Durrant .name = "str",
6641a72d9aeSPaul Durrant .description = "Virtual Disk specifier: d*p*/xvd*/hd*/sd*",
6651a72d9aeSPaul Durrant .get = xen_block_get_vdev,
6661a72d9aeSPaul Durrant .set = xen_block_set_vdev,
6671a72d9aeSPaul Durrant };
6681a72d9aeSPaul Durrant
6691a72d9aeSPaul Durrant static Property xen_block_props[] = {
6701a72d9aeSPaul Durrant DEFINE_PROP("vdev", XenBlockDevice, props.vdev,
6711a72d9aeSPaul Durrant xen_block_prop_vdev, XenBlockVdev),
672b6af8926SPaul Durrant DEFINE_BLOCK_PROPERTIES(XenBlockDevice, props.conf),
673b6af8926SPaul Durrant DEFINE_PROP_UINT32("max-ring-page-order", XenBlockDevice,
674b6af8926SPaul Durrant props.max_ring_page_order, 4),
675b6af8926SPaul Durrant DEFINE_PROP_LINK("iothread", XenBlockDevice, props.iothread,
676b6af8926SPaul Durrant TYPE_IOTHREAD, IOThread *),
6771a72d9aeSPaul Durrant DEFINE_PROP_END_OF_LIST()
6781a72d9aeSPaul Durrant };
6791a72d9aeSPaul Durrant
xen_block_class_init(ObjectClass * class,void * data)6801a72d9aeSPaul Durrant static void xen_block_class_init(ObjectClass *class, void *data)
6811a72d9aeSPaul Durrant {
6821a72d9aeSPaul Durrant DeviceClass *dev_class = DEVICE_CLASS(class);
6831a72d9aeSPaul Durrant XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class);
6841a72d9aeSPaul Durrant
685db9ff46eSPaul Durrant xendev_class->backend = "qdisk";
686b6af8926SPaul Durrant xendev_class->device = "vbd";
687094a2239SPaul Durrant xendev_class->get_name = xen_block_get_name;
6881a72d9aeSPaul Durrant xendev_class->realize = xen_block_realize;
68982a29e30SPaul Durrant xendev_class->frontend_changed = xen_block_frontend_changed;
6901a72d9aeSPaul Durrant xendev_class->unrealize = xen_block_unrealize;
6911a72d9aeSPaul Durrant
6924f67d30bSMarc-André Lureau device_class_set_props(dev_class, xen_block_props);
6931a72d9aeSPaul Durrant }
6941a72d9aeSPaul Durrant
6951a72d9aeSPaul Durrant static const TypeInfo xen_block_type_info = {
6961a72d9aeSPaul Durrant .name = TYPE_XEN_BLOCK_DEVICE,
6971a72d9aeSPaul Durrant .parent = TYPE_XEN_DEVICE,
6981a72d9aeSPaul Durrant .instance_size = sizeof(XenBlockDevice),
6991a72d9aeSPaul Durrant .abstract = true,
7001a72d9aeSPaul Durrant .class_size = sizeof(XenBlockDeviceClass),
7011a72d9aeSPaul Durrant .class_init = xen_block_class_init,
7021a72d9aeSPaul Durrant };
7031a72d9aeSPaul Durrant
xen_disk_unrealize(XenBlockDevice * blockdev)704b69c3c21SMarkus Armbruster static void xen_disk_unrealize(XenBlockDevice *blockdev)
7051a72d9aeSPaul Durrant {
7061a72d9aeSPaul Durrant trace_xen_disk_unrealize();
7071a72d9aeSPaul Durrant }
7081a72d9aeSPaul Durrant
xen_disk_realize(XenBlockDevice * blockdev,Error ** errp)7091a72d9aeSPaul Durrant static void xen_disk_realize(XenBlockDevice *blockdev, Error **errp)
7101a72d9aeSPaul Durrant {
711b6af8926SPaul Durrant BlockConf *conf = &blockdev->props.conf;
712b6af8926SPaul Durrant
7131a72d9aeSPaul Durrant trace_xen_disk_realize();
714b6af8926SPaul Durrant
715b6af8926SPaul Durrant blockdev->device_type = "disk";
716b6af8926SPaul Durrant
717b6af8926SPaul Durrant if (!conf->blk) {
718b6af8926SPaul Durrant error_setg(errp, "drive property not set");
719b6af8926SPaul Durrant return;
720b6af8926SPaul Durrant }
721b6af8926SPaul Durrant
72286b1cf32SKevin Wolf blockdev->info = blk_supports_write_perm(conf->blk) ? 0 : VDISK_READONLY;
7231a72d9aeSPaul Durrant }
7241a72d9aeSPaul Durrant
xen_disk_class_init(ObjectClass * class,void * data)7251a72d9aeSPaul Durrant static void xen_disk_class_init(ObjectClass *class, void *data)
7261a72d9aeSPaul Durrant {
7271a72d9aeSPaul Durrant DeviceClass *dev_class = DEVICE_CLASS(class);
7281a72d9aeSPaul Durrant XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class);
7291a72d9aeSPaul Durrant
7301a72d9aeSPaul Durrant blockdev_class->realize = xen_disk_realize;
7311a72d9aeSPaul Durrant blockdev_class->unrealize = xen_disk_unrealize;
7321a72d9aeSPaul Durrant
7331a72d9aeSPaul Durrant dev_class->desc = "Xen Disk Device";
7341a72d9aeSPaul Durrant }
7351a72d9aeSPaul Durrant
7361a72d9aeSPaul Durrant static const TypeInfo xen_disk_type_info = {
7371a72d9aeSPaul Durrant .name = TYPE_XEN_DISK_DEVICE,
7381a72d9aeSPaul Durrant .parent = TYPE_XEN_BLOCK_DEVICE,
7391a72d9aeSPaul Durrant .instance_size = sizeof(XenDiskDevice),
7401a72d9aeSPaul Durrant .class_init = xen_disk_class_init,
7411a72d9aeSPaul Durrant };
7421a72d9aeSPaul Durrant
xen_cdrom_unrealize(XenBlockDevice * blockdev)743b69c3c21SMarkus Armbruster static void xen_cdrom_unrealize(XenBlockDevice *blockdev)
7441a72d9aeSPaul Durrant {
7451a72d9aeSPaul Durrant trace_xen_cdrom_unrealize();
7461a72d9aeSPaul Durrant }
7471a72d9aeSPaul Durrant
xen_cdrom_realize(XenBlockDevice * blockdev,Error ** errp)7481a72d9aeSPaul Durrant static void xen_cdrom_realize(XenBlockDevice *blockdev, Error **errp)
7491a72d9aeSPaul Durrant {
750b6af8926SPaul Durrant BlockConf *conf = &blockdev->props.conf;
751b6af8926SPaul Durrant
7521a72d9aeSPaul Durrant trace_xen_cdrom_realize();
753b6af8926SPaul Durrant
754b6af8926SPaul Durrant blockdev->device_type = "cdrom";
755b6af8926SPaul Durrant
756b6af8926SPaul Durrant if (!conf->blk) {
757b6af8926SPaul Durrant int rc;
758b6af8926SPaul Durrant
759b6af8926SPaul Durrant /* Set up an empty drive */
760d861ab3aSKevin Wolf conf->blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
761b6af8926SPaul Durrant
762b6af8926SPaul Durrant rc = blk_attach_dev(conf->blk, DEVICE(blockdev));
763b6af8926SPaul Durrant if (!rc) {
764b6af8926SPaul Durrant error_setg_errno(errp, -rc, "failed to create drive");
765b6af8926SPaul Durrant return;
766b6af8926SPaul Durrant }
767b6af8926SPaul Durrant }
768b6af8926SPaul Durrant
769b6af8926SPaul Durrant blockdev->info = VDISK_READONLY | VDISK_CDROM;
7701a72d9aeSPaul Durrant }
7711a72d9aeSPaul Durrant
xen_cdrom_class_init(ObjectClass * class,void * data)7721a72d9aeSPaul Durrant static void xen_cdrom_class_init(ObjectClass *class, void *data)
7731a72d9aeSPaul Durrant {
7741a72d9aeSPaul Durrant DeviceClass *dev_class = DEVICE_CLASS(class);
7751a72d9aeSPaul Durrant XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class);
7761a72d9aeSPaul Durrant
7771a72d9aeSPaul Durrant blockdev_class->realize = xen_cdrom_realize;
7781a72d9aeSPaul Durrant blockdev_class->unrealize = xen_cdrom_unrealize;
7791a72d9aeSPaul Durrant
7801a72d9aeSPaul Durrant dev_class->desc = "Xen CD-ROM Device";
7811a72d9aeSPaul Durrant }
7821a72d9aeSPaul Durrant
7831a72d9aeSPaul Durrant static const TypeInfo xen_cdrom_type_info = {
7841a72d9aeSPaul Durrant .name = TYPE_XEN_CDROM_DEVICE,
7851a72d9aeSPaul Durrant .parent = TYPE_XEN_BLOCK_DEVICE,
7861a72d9aeSPaul Durrant .instance_size = sizeof(XenCDRomDevice),
7871a72d9aeSPaul Durrant .class_init = xen_cdrom_class_init,
7881a72d9aeSPaul Durrant };
7891a72d9aeSPaul Durrant
xen_block_register_types(void)7901a72d9aeSPaul Durrant static void xen_block_register_types(void)
7911a72d9aeSPaul Durrant {
7921a72d9aeSPaul Durrant type_register_static(&xen_block_type_info);
7931a72d9aeSPaul Durrant type_register_static(&xen_disk_type_info);
7941a72d9aeSPaul Durrant type_register_static(&xen_cdrom_type_info);
7951a72d9aeSPaul Durrant }
7961a72d9aeSPaul Durrant
type_init(xen_block_register_types)7971a72d9aeSPaul Durrant type_init(xen_block_register_types)
798db9ff46eSPaul Durrant
799db9ff46eSPaul Durrant static void xen_block_blockdev_del(const char *node_name, Error **errp)
800db9ff46eSPaul Durrant {
801db9ff46eSPaul Durrant trace_xen_block_blockdev_del(node_name);
802db9ff46eSPaul Durrant
803db9ff46eSPaul Durrant qmp_blockdev_del(node_name, errp);
804db9ff46eSPaul Durrant }
805db9ff46eSPaul Durrant
xen_block_blockdev_add(const char * id,QDict * qdict,Error ** errp)806db9ff46eSPaul Durrant static char *xen_block_blockdev_add(const char *id, QDict *qdict,
807db9ff46eSPaul Durrant Error **errp)
808db9ff46eSPaul Durrant {
8091de7096dSVladimir Sementsov-Ogievskiy ERRP_GUARD();
810db9ff46eSPaul Durrant const char *driver = qdict_get_try_str(qdict, "driver");
811db9ff46eSPaul Durrant BlockdevOptions *options = NULL;
812db9ff46eSPaul Durrant char *node_name;
813db9ff46eSPaul Durrant Visitor *v;
814db9ff46eSPaul Durrant
815db9ff46eSPaul Durrant if (!driver) {
816db9ff46eSPaul Durrant error_setg(errp, "no 'driver' parameter");
817db9ff46eSPaul Durrant return NULL;
818db9ff46eSPaul Durrant }
819db9ff46eSPaul Durrant
820db9ff46eSPaul Durrant node_name = g_strdup_printf("%s-%s", id, driver);
821db9ff46eSPaul Durrant qdict_put_str(qdict, "node-name", node_name);
822db9ff46eSPaul Durrant
823db9ff46eSPaul Durrant trace_xen_block_blockdev_add(node_name);
824db9ff46eSPaul Durrant
825db9ff46eSPaul Durrant v = qobject_input_visitor_new(QOBJECT(qdict));
826b11a093cSMarkus Armbruster visit_type_BlockdevOptions(v, NULL, &options, errp);
827db9ff46eSPaul Durrant visit_free(v);
828b11a093cSMarkus Armbruster if (!options) {
829db9ff46eSPaul Durrant goto fail;
830db9ff46eSPaul Durrant }
831db9ff46eSPaul Durrant
8321de7096dSVladimir Sementsov-Ogievskiy qmp_blockdev_add(options, errp);
833db9ff46eSPaul Durrant
8341de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
835db9ff46eSPaul Durrant goto fail;
836db9ff46eSPaul Durrant }
837db9ff46eSPaul Durrant
838db9ff46eSPaul Durrant qapi_free_BlockdevOptions(options);
839db9ff46eSPaul Durrant
840db9ff46eSPaul Durrant return node_name;
841db9ff46eSPaul Durrant
842db9ff46eSPaul Durrant fail:
843db9ff46eSPaul Durrant if (options) {
844db9ff46eSPaul Durrant qapi_free_BlockdevOptions(options);
845db9ff46eSPaul Durrant }
846db9ff46eSPaul Durrant g_free(node_name);
847db9ff46eSPaul Durrant
848db9ff46eSPaul Durrant return NULL;
849db9ff46eSPaul Durrant }
850db9ff46eSPaul Durrant
xen_block_drive_destroy(XenBlockDrive * drive,Error ** errp)851db9ff46eSPaul Durrant static void xen_block_drive_destroy(XenBlockDrive *drive, Error **errp)
852db9ff46eSPaul Durrant {
8531de7096dSVladimir Sementsov-Ogievskiy ERRP_GUARD();
854db9ff46eSPaul Durrant char *node_name = drive->node_name;
855db9ff46eSPaul Durrant
856db9ff46eSPaul Durrant if (node_name) {
8571de7096dSVladimir Sementsov-Ogievskiy xen_block_blockdev_del(node_name, errp);
8581de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
859db9ff46eSPaul Durrant return;
860db9ff46eSPaul Durrant }
861db9ff46eSPaul Durrant g_free(node_name);
862db9ff46eSPaul Durrant drive->node_name = NULL;
863db9ff46eSPaul Durrant }
864db9ff46eSPaul Durrant g_free(drive->id);
865db9ff46eSPaul Durrant g_free(drive);
866db9ff46eSPaul Durrant }
867db9ff46eSPaul Durrant
xen_block_drive_create(const char * id,const char * device_type,QDict * opts,Error ** errp)868db9ff46eSPaul Durrant static XenBlockDrive *xen_block_drive_create(const char *id,
869db9ff46eSPaul Durrant const char *device_type,
870db9ff46eSPaul Durrant QDict *opts, Error **errp)
871db9ff46eSPaul Durrant {
8721de7096dSVladimir Sementsov-Ogievskiy ERRP_GUARD();
873db9ff46eSPaul Durrant const char *params = qdict_get_try_str(opts, "params");
874db9ff46eSPaul Durrant const char *mode = qdict_get_try_str(opts, "mode");
875db9ff46eSPaul Durrant const char *direct_io_safe = qdict_get_try_str(opts, "direct-io-safe");
876db9ff46eSPaul Durrant const char *discard_enable = qdict_get_try_str(opts, "discard-enable");
877db9ff46eSPaul Durrant char *driver = NULL;
878db9ff46eSPaul Durrant char *filename = NULL;
879db9ff46eSPaul Durrant XenBlockDrive *drive = NULL;
880db9ff46eSPaul Durrant QDict *file_layer;
881db9ff46eSPaul Durrant QDict *driver_layer;
88218982939SAnthony PERARD struct stat st;
88318982939SAnthony PERARD int rc;
884db9ff46eSPaul Durrant
885db9ff46eSPaul Durrant if (params) {
886db9ff46eSPaul Durrant char **v = g_strsplit(params, ":", 2);
887db9ff46eSPaul Durrant
888db9ff46eSPaul Durrant if (v[1] == NULL) {
889db9ff46eSPaul Durrant filename = g_strdup(v[0]);
890db9ff46eSPaul Durrant driver = g_strdup("raw");
891db9ff46eSPaul Durrant } else {
892db9ff46eSPaul Durrant if (strcmp(v[0], "aio") == 0) {
893db9ff46eSPaul Durrant driver = g_strdup("raw");
894db9ff46eSPaul Durrant } else if (strcmp(v[0], "vhd") == 0) {
895db9ff46eSPaul Durrant driver = g_strdup("vpc");
896db9ff46eSPaul Durrant } else {
897db9ff46eSPaul Durrant driver = g_strdup(v[0]);
898db9ff46eSPaul Durrant }
899db9ff46eSPaul Durrant filename = g_strdup(v[1]);
900db9ff46eSPaul Durrant }
901db9ff46eSPaul Durrant
902db9ff46eSPaul Durrant g_strfreev(v);
903156ac944SPaul Durrant } else {
904156ac944SPaul Durrant error_setg(errp, "no params");
905db9ff46eSPaul Durrant goto done;
906db9ff46eSPaul Durrant }
907156ac944SPaul Durrant
908156ac944SPaul Durrant assert(filename);
909db9ff46eSPaul Durrant assert(driver);
910db9ff46eSPaul Durrant
911db9ff46eSPaul Durrant drive = g_new0(XenBlockDrive, 1);
912db9ff46eSPaul Durrant drive->id = g_strdup(id);
913db9ff46eSPaul Durrant
91418982939SAnthony PERARD rc = stat(filename, &st);
91518982939SAnthony PERARD if (rc) {
91618982939SAnthony PERARD error_setg_errno(errp, errno, "Could not stat file '%s'", filename);
91718982939SAnthony PERARD goto done;
91818982939SAnthony PERARD }
919aa362435SAnthony PERARD
920aa362435SAnthony PERARD file_layer = qdict_new();
921aa362435SAnthony PERARD driver_layer = qdict_new();
922aa362435SAnthony PERARD
92318982939SAnthony PERARD if (S_ISBLK(st.st_mode)) {
92418982939SAnthony PERARD qdict_put_str(file_layer, "driver", "host_device");
92518982939SAnthony PERARD } else {
926db9ff46eSPaul Durrant qdict_put_str(file_layer, "driver", "file");
92718982939SAnthony PERARD }
92818982939SAnthony PERARD
929db9ff46eSPaul Durrant qdict_put_str(file_layer, "filename", filename);
930db9ff46eSPaul Durrant
931db9ff46eSPaul Durrant if (mode && *mode != 'w') {
932db9ff46eSPaul Durrant qdict_put_bool(file_layer, "read-only", true);
933db9ff46eSPaul Durrant }
934db9ff46eSPaul Durrant
935db9ff46eSPaul Durrant if (direct_io_safe) {
936db9ff46eSPaul Durrant unsigned long value;
937db9ff46eSPaul Durrant
938db9ff46eSPaul Durrant if (!qemu_strtoul(direct_io_safe, NULL, 2, &value) && !!value) {
939db9ff46eSPaul Durrant QDict *cache_qdict = qdict_new();
940db9ff46eSPaul Durrant
941db9ff46eSPaul Durrant qdict_put_bool(cache_qdict, "direct", true);
942ad85b0b4SMarkus Armbruster qdict_put(file_layer, "cache", cache_qdict);
943db9ff46eSPaul Durrant
944db9ff46eSPaul Durrant qdict_put_str(file_layer, "aio", "native");
945db9ff46eSPaul Durrant }
946db9ff46eSPaul Durrant }
947db9ff46eSPaul Durrant
948db9ff46eSPaul Durrant if (discard_enable) {
949db9ff46eSPaul Durrant unsigned long value;
950db9ff46eSPaul Durrant
951db9ff46eSPaul Durrant if (!qemu_strtoul(discard_enable, NULL, 2, &value) && !!value) {
952db9ff46eSPaul Durrant qdict_put_str(file_layer, "discard", "unmap");
95315f08450SPaul Durrant qdict_put_str(driver_layer, "discard", "unmap");
954db9ff46eSPaul Durrant }
955db9ff46eSPaul Durrant }
956db9ff46eSPaul Durrant
957db9ff46eSPaul Durrant /*
958db9ff46eSPaul Durrant * It is necessary to turn file locking off as an emulated device
959db9ff46eSPaul Durrant * may have already opened the same image file.
960db9ff46eSPaul Durrant */
961db9ff46eSPaul Durrant qdict_put_str(file_layer, "locking", "off");
962db9ff46eSPaul Durrant
963db9ff46eSPaul Durrant qdict_put_str(driver_layer, "driver", driver);
964156ac944SPaul Durrant
965ad85b0b4SMarkus Armbruster qdict_put(driver_layer, "file", file_layer);
966db9ff46eSPaul Durrant
967db9ff46eSPaul Durrant g_assert(!drive->node_name);
968db9ff46eSPaul Durrant drive->node_name = xen_block_blockdev_add(drive->id, driver_layer,
9691de7096dSVladimir Sementsov-Ogievskiy errp);
970db9ff46eSPaul Durrant
971156ac944SPaul Durrant qobject_unref(driver_layer);
972db9ff46eSPaul Durrant
973156ac944SPaul Durrant done:
974aa362435SAnthony PERARD g_free(filename);
975aa362435SAnthony PERARD g_free(driver);
9761de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
977db9ff46eSPaul Durrant xen_block_drive_destroy(drive, NULL);
978db9ff46eSPaul Durrant return NULL;
979db9ff46eSPaul Durrant }
980db9ff46eSPaul Durrant
981db9ff46eSPaul Durrant return drive;
982db9ff46eSPaul Durrant }
983db9ff46eSPaul Durrant
xen_block_drive_get_node_name(XenBlockDrive * drive)984db9ff46eSPaul Durrant static const char *xen_block_drive_get_node_name(XenBlockDrive *drive)
985db9ff46eSPaul Durrant {
986db9ff46eSPaul Durrant return drive->node_name ? drive->node_name : "";
987db9ff46eSPaul Durrant }
988db9ff46eSPaul Durrant
xen_block_iothread_destroy(XenBlockIOThread * iothread,Error ** errp)989db9ff46eSPaul Durrant static void xen_block_iothread_destroy(XenBlockIOThread *iothread,
990db9ff46eSPaul Durrant Error **errp)
991db9ff46eSPaul Durrant {
992db9ff46eSPaul Durrant qmp_object_del(iothread->id, errp);
993db9ff46eSPaul Durrant
994db9ff46eSPaul Durrant g_free(iothread->id);
995db9ff46eSPaul Durrant g_free(iothread);
996db9ff46eSPaul Durrant }
997db9ff46eSPaul Durrant
xen_block_iothread_create(const char * id,Error ** errp)998db9ff46eSPaul Durrant static XenBlockIOThread *xen_block_iothread_create(const char *id,
999db9ff46eSPaul Durrant Error **errp)
1000db9ff46eSPaul Durrant {
10011de7096dSVladimir Sementsov-Ogievskiy ERRP_GUARD();
1002db9ff46eSPaul Durrant XenBlockIOThread *iothread = g_new(XenBlockIOThread, 1);
10039151e59aSKevin Wolf ObjectOptions *opts;
1004db9ff46eSPaul Durrant
1005db9ff46eSPaul Durrant iothread->id = g_strdup(id);
1006db9ff46eSPaul Durrant
10079151e59aSKevin Wolf opts = g_new(ObjectOptions, 1);
10089151e59aSKevin Wolf *opts = (ObjectOptions) {
10099151e59aSKevin Wolf .qom_type = OBJECT_TYPE_IOTHREAD,
10109151e59aSKevin Wolf .id = g_strdup(id),
10119151e59aSKevin Wolf };
10129151e59aSKevin Wolf qmp_object_add(opts, errp);
10139151e59aSKevin Wolf qapi_free_ObjectOptions(opts);
10145f07c4d6SKevin Wolf
10151de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
1016db9ff46eSPaul Durrant g_free(iothread->id);
1017db9ff46eSPaul Durrant g_free(iothread);
1018db9ff46eSPaul Durrant return NULL;
1019db9ff46eSPaul Durrant }
1020db9ff46eSPaul Durrant
1021db9ff46eSPaul Durrant return iothread;
1022db9ff46eSPaul Durrant }
1023db9ff46eSPaul Durrant
xen_block_device_create(XenBackendInstance * backend,QDict * opts,Error ** errp)1024db9ff46eSPaul Durrant static void xen_block_device_create(XenBackendInstance *backend,
1025db9ff46eSPaul Durrant QDict *opts, Error **errp)
1026db9ff46eSPaul Durrant {
10271de7096dSVladimir Sementsov-Ogievskiy ERRP_GUARD();
1028db9ff46eSPaul Durrant XenBus *xenbus = xen_backend_get_bus(backend);
1029db9ff46eSPaul Durrant const char *name = xen_backend_get_name(backend);
1030db9ff46eSPaul Durrant unsigned long number;
1031db9ff46eSPaul Durrant const char *vdev, *device_type;
1032db9ff46eSPaul Durrant XenBlockDrive *drive = NULL;
1033db9ff46eSPaul Durrant XenBlockIOThread *iothread = NULL;
1034db9ff46eSPaul Durrant XenDevice *xendev = NULL;
1035db9ff46eSPaul Durrant const char *type;
1036db9ff46eSPaul Durrant XenBlockDevice *blockdev;
1037db9ff46eSPaul Durrant
1038db9ff46eSPaul Durrant if (qemu_strtoul(name, NULL, 10, &number)) {
1039db9ff46eSPaul Durrant error_setg(errp, "failed to parse name '%s'", name);
1040db9ff46eSPaul Durrant goto fail;
1041db9ff46eSPaul Durrant }
1042db9ff46eSPaul Durrant
1043db9ff46eSPaul Durrant trace_xen_block_device_create(number);
1044db9ff46eSPaul Durrant
1045db9ff46eSPaul Durrant vdev = qdict_get_try_str(opts, "dev");
1046db9ff46eSPaul Durrant if (!vdev) {
1047db9ff46eSPaul Durrant error_setg(errp, "no dev parameter");
1048db9ff46eSPaul Durrant goto fail;
1049db9ff46eSPaul Durrant }
1050db9ff46eSPaul Durrant
1051db9ff46eSPaul Durrant device_type = qdict_get_try_str(opts, "device-type");
1052db9ff46eSPaul Durrant if (!device_type) {
1053db9ff46eSPaul Durrant error_setg(errp, "no device-type parameter");
1054db9ff46eSPaul Durrant goto fail;
1055db9ff46eSPaul Durrant }
1056db9ff46eSPaul Durrant
1057db9ff46eSPaul Durrant if (!strcmp(device_type, "disk")) {
1058db9ff46eSPaul Durrant type = TYPE_XEN_DISK_DEVICE;
1059db9ff46eSPaul Durrant } else if (!strcmp(device_type, "cdrom")) {
1060db9ff46eSPaul Durrant type = TYPE_XEN_CDROM_DEVICE;
1061db9ff46eSPaul Durrant } else {
1062db9ff46eSPaul Durrant error_setg(errp, "invalid device-type parameter '%s'", device_type);
1063db9ff46eSPaul Durrant goto fail;
1064db9ff46eSPaul Durrant }
1065db9ff46eSPaul Durrant
10661de7096dSVladimir Sementsov-Ogievskiy drive = xen_block_drive_create(vdev, device_type, opts, errp);
1067db9ff46eSPaul Durrant if (!drive) {
10681de7096dSVladimir Sementsov-Ogievskiy error_prepend(errp, "failed to create drive: ");
1069db9ff46eSPaul Durrant goto fail;
1070db9ff46eSPaul Durrant }
1071db9ff46eSPaul Durrant
10721de7096dSVladimir Sementsov-Ogievskiy iothread = xen_block_iothread_create(vdev, errp);
10731de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
10741de7096dSVladimir Sementsov-Ogievskiy error_prepend(errp, "failed to create iothread: ");
1075db9ff46eSPaul Durrant goto fail;
1076db9ff46eSPaul Durrant }
1077db9ff46eSPaul Durrant
1078df707969SMarkus Armbruster xendev = XEN_DEVICE(qdev_new(type));
1079db9ff46eSPaul Durrant blockdev = XEN_BLOCK_DEVICE(xendev);
1080db9ff46eSPaul Durrant
1081778a2dc5SMarkus Armbruster if (!object_property_set_str(OBJECT(xendev), "vdev", vdev,
10821de7096dSVladimir Sementsov-Ogievskiy errp)) {
10831de7096dSVladimir Sementsov-Ogievskiy error_prepend(errp, "failed to set 'vdev': ");
1084db9ff46eSPaul Durrant goto fail;
1085db9ff46eSPaul Durrant }
1086db9ff46eSPaul Durrant
1087778a2dc5SMarkus Armbruster if (!object_property_set_str(OBJECT(xendev), "drive",
1088778a2dc5SMarkus Armbruster xen_block_drive_get_node_name(drive),
10891de7096dSVladimir Sementsov-Ogievskiy errp)) {
10901de7096dSVladimir Sementsov-Ogievskiy error_prepend(errp, "failed to set 'drive': ");
1091db9ff46eSPaul Durrant goto fail;
1092db9ff46eSPaul Durrant }
1093db9ff46eSPaul Durrant
1094778a2dc5SMarkus Armbruster if (!object_property_set_str(OBJECT(xendev), "iothread", iothread->id,
10951de7096dSVladimir Sementsov-Ogievskiy errp)) {
10961de7096dSVladimir Sementsov-Ogievskiy error_prepend(errp, "failed to set 'iothread': ");
1097db9ff46eSPaul Durrant goto fail;
1098db9ff46eSPaul Durrant }
1099db9ff46eSPaul Durrant
1100db9ff46eSPaul Durrant blockdev->iothread = iothread;
1101db9ff46eSPaul Durrant blockdev->drive = drive;
1102db9ff46eSPaul Durrant
11031de7096dSVladimir Sementsov-Ogievskiy if (!qdev_realize_and_unref(DEVICE(xendev), BUS(xenbus), errp)) {
11041de7096dSVladimir Sementsov-Ogievskiy error_prepend(errp, "realization of device %s failed: ", type);
1105db9ff46eSPaul Durrant goto fail;
1106db9ff46eSPaul Durrant }
1107db9ff46eSPaul Durrant
1108db9ff46eSPaul Durrant xen_backend_set_device(backend, xendev);
1109db9ff46eSPaul Durrant return;
1110db9ff46eSPaul Durrant
1111db9ff46eSPaul Durrant fail:
1112db9ff46eSPaul Durrant if (xendev) {
1113db9ff46eSPaul Durrant object_unparent(OBJECT(xendev));
1114db9ff46eSPaul Durrant }
1115db9ff46eSPaul Durrant
1116db9ff46eSPaul Durrant if (iothread) {
1117db9ff46eSPaul Durrant xen_block_iothread_destroy(iothread, NULL);
1118db9ff46eSPaul Durrant }
1119db9ff46eSPaul Durrant
1120db9ff46eSPaul Durrant if (drive) {
1121db9ff46eSPaul Durrant xen_block_drive_destroy(drive, NULL);
1122db9ff46eSPaul Durrant }
1123db9ff46eSPaul Durrant }
1124db9ff46eSPaul Durrant
xen_block_device_destroy(XenBackendInstance * backend,Error ** errp)1125db9ff46eSPaul Durrant static void xen_block_device_destroy(XenBackendInstance *backend,
1126db9ff46eSPaul Durrant Error **errp)
1127db9ff46eSPaul Durrant {
11281de7096dSVladimir Sementsov-Ogievskiy ERRP_GUARD();
1129db9ff46eSPaul Durrant XenDevice *xendev = xen_backend_get_device(backend);
1130db9ff46eSPaul Durrant XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
1131db9ff46eSPaul Durrant XenBlockVdev *vdev = &blockdev->props.vdev;
1132db9ff46eSPaul Durrant XenBlockDrive *drive = blockdev->drive;
1133db9ff46eSPaul Durrant XenBlockIOThread *iothread = blockdev->iothread;
1134db9ff46eSPaul Durrant
1135db9ff46eSPaul Durrant trace_xen_block_device_destroy(vdev->number);
1136db9ff46eSPaul Durrant
1137db9ff46eSPaul Durrant object_unparent(OBJECT(xendev));
1138db9ff46eSPaul Durrant
1139b807ca3fSAnthony PERARD /*
1140b807ca3fSAnthony PERARD * Drain all pending RCU callbacks as object_unparent() frees `xendev'
1141b807ca3fSAnthony PERARD * in a RCU callback.
1142b807ca3fSAnthony PERARD * And due to the property "drive" still existing in `xendev', we
1143b807ca3fSAnthony PERARD * can't destroy the XenBlockDrive associated with `xendev' with
1144b807ca3fSAnthony PERARD * xen_block_drive_destroy() below.
1145b807ca3fSAnthony PERARD */
1146b807ca3fSAnthony PERARD drain_call_rcu();
1147b807ca3fSAnthony PERARD
1148db9ff46eSPaul Durrant if (iothread) {
11491de7096dSVladimir Sementsov-Ogievskiy xen_block_iothread_destroy(iothread, errp);
11501de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
11511de7096dSVladimir Sementsov-Ogievskiy error_prepend(errp, "failed to destroy iothread: ");
1152db9ff46eSPaul Durrant return;
1153db9ff46eSPaul Durrant }
1154db9ff46eSPaul Durrant }
1155db9ff46eSPaul Durrant
1156db9ff46eSPaul Durrant if (drive) {
11571de7096dSVladimir Sementsov-Ogievskiy xen_block_drive_destroy(drive, errp);
11581de7096dSVladimir Sementsov-Ogievskiy if (*errp) {
11591de7096dSVladimir Sementsov-Ogievskiy error_prepend(errp, "failed to destroy drive: ");
1160526ab8e8SMarkus Armbruster return;
1161db9ff46eSPaul Durrant }
1162db9ff46eSPaul Durrant }
1163db9ff46eSPaul Durrant }
1164db9ff46eSPaul Durrant
1165db9ff46eSPaul Durrant static const XenBackendInfo xen_block_backend_info = {
1166db9ff46eSPaul Durrant .type = "qdisk",
1167db9ff46eSPaul Durrant .create = xen_block_device_create,
1168db9ff46eSPaul Durrant .destroy = xen_block_device_destroy,
1169db9ff46eSPaul Durrant };
1170db9ff46eSPaul Durrant
xen_block_register_backend(void)1171db9ff46eSPaul Durrant static void xen_block_register_backend(void)
1172db9ff46eSPaul Durrant {
1173db9ff46eSPaul Durrant xen_backend_register(&xen_block_backend_info);
1174db9ff46eSPaul Durrant }
1175db9ff46eSPaul Durrant
1176db9ff46eSPaul Durrant xen_backend_init(xen_block_register_backend);
1177