1
2
3
4
5
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
33static 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
41static 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
52static 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
139static void xen_block_unrealize(XenDevice *xendev, Error **errp)
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
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, errp);
161 }
162}
163
164static 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
177static 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
187
188
189 xen_device_backend_printf(xendev, "state", "%u", state);
190}
191
192static const BlockDevOps xen_block_dev_ops = {
193 .resize_cb = xen_block_resize_cb,
194};
195
196static void xen_block_realize(XenDevice *xendev, Error **errp)
197{
198 XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
199 XenBlockDeviceClass *blockdev_class =
200 XEN_BLOCK_DEVICE_GET_CLASS(xendev);
201 const char *type = object_get_typename(OBJECT(blockdev));
202 XenBlockVdev *vdev = &blockdev->props.vdev;
203 BlockConf *conf = &blockdev->props.conf;
204 BlockBackend *blk = conf->blk;
205 Error *local_err = NULL;
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, &local_err);
216 if (local_err) {
217 error_propagate(errp, local_err);
218 return;
219 }
220 }
221
222
223
224
225
226 assert(blk);
227 if (!blk_is_inserted(blk)) {
228 error_setg(errp, "device needs media, but drive is empty");
229 return;
230 }
231
232 if (!blkconf_apply_backend_options(conf, blockdev->info & VDISK_READONLY,
233 true, errp)) {
234 return;
235 }
236
237 if (!(blockdev->info & VDISK_CDROM) &&
238 !blkconf_geometry(conf, NULL, 65535, 255, 255, errp)) {
239 return;
240 }
241
242 blkconf_blocksizes(conf);
243
244 if (conf->logical_block_size > conf->physical_block_size) {
245 error_setg(
246 errp, "logical_block_size > physical_block_size not supported");
247 return;
248 }
249
250 blk_set_dev_ops(blk, &xen_block_dev_ops, blockdev);
251 blk_set_guest_block_size(blk, conf->logical_block_size);
252
253 if (conf->discard_granularity == -1) {
254 conf->discard_granularity = conf->physical_block_size;
255 }
256
257 if (blk_get_flags(blk) & BDRV_O_UNMAP) {
258 xen_device_backend_printf(xendev, "feature-discard", "%u", 1);
259 xen_device_backend_printf(xendev, "discard-granularity", "%u",
260 conf->discard_granularity);
261 }
262
263 xen_device_backend_printf(xendev, "feature-flush-cache", "%u", 1);
264 xen_device_backend_printf(xendev, "max-ring-page-order", "%u",
265 blockdev->props.max_ring_page_order);
266 xen_device_backend_printf(xendev, "info", "%u", blockdev->info);
267
268 xen_device_frontend_printf(xendev, "virtual-device", "%lu",
269 vdev->number);
270 xen_device_frontend_printf(xendev, "device-type", "%s",
271 blockdev->device_type);
272
273 xen_device_backend_printf(xendev, "sector-size", "%u",
274 conf->logical_block_size);
275
276 xen_block_set_size(blockdev);
277
278 blockdev->dataplane =
279 xen_block_dataplane_create(xendev, blk, conf->logical_block_size,
280 blockdev->props.iothread);
281}
282
283static void xen_block_frontend_changed(XenDevice *xendev,
284 enum xenbus_state frontend_state,
285 Error **errp)
286{
287 enum xenbus_state backend_state = xen_device_backend_get_state(xendev);
288 Error *local_err = NULL;
289
290 switch (frontend_state) {
291 case XenbusStateInitialised:
292 case XenbusStateConnected:
293 if (backend_state == XenbusStateConnected) {
294 break;
295 }
296
297 xen_block_disconnect(xendev, &local_err);
298 if (local_err) {
299 error_propagate(errp, local_err);
300 break;
301 }
302
303 xen_block_connect(xendev, &local_err);
304 if (local_err) {
305 error_propagate(errp, local_err);
306 break;
307 }
308
309 xen_device_backend_set_state(xendev, XenbusStateConnected);
310 break;
311
312 case XenbusStateClosing:
313 xen_device_backend_set_state(xendev, XenbusStateClosing);
314 break;
315
316 case XenbusStateClosed:
317 case XenbusStateUnknown:
318 xen_block_disconnect(xendev, &local_err);
319 if (local_err) {
320 error_propagate(errp, local_err);
321 break;
322 }
323
324 xen_device_backend_set_state(xendev, XenbusStateClosed);
325 break;
326
327 default:
328 break;
329 }
330}
331
332static char *disk_to_vbd_name(unsigned int disk)
333{
334 char *name, *prefix = (disk >= 26) ?
335 disk_to_vbd_name((disk / 26) - 1) : g_strdup("");
336
337 name = g_strdup_printf("%s%c", prefix, 'a' + disk % 26);
338 g_free(prefix);
339
340 return name;
341}
342
343static void xen_block_get_vdev(Object *obj, Visitor *v, const char *name,
344 void *opaque, Error **errp)
345{
346 DeviceState *dev = DEVICE(obj);
347 Property *prop = opaque;
348 XenBlockVdev *vdev = qdev_get_prop_ptr(dev, prop);
349 char *str;
350
351 switch (vdev->type) {
352 case XEN_BLOCK_VDEV_TYPE_DP:
353 str = g_strdup_printf("d%lup%lu", vdev->disk, vdev->partition);
354 break;
355
356 case XEN_BLOCK_VDEV_TYPE_XVD:
357 case XEN_BLOCK_VDEV_TYPE_HD:
358 case XEN_BLOCK_VDEV_TYPE_SD: {
359 char *name = disk_to_vbd_name(vdev->disk);
360
361 str = g_strdup_printf("%s%s%lu",
362 (vdev->type == XEN_BLOCK_VDEV_TYPE_XVD) ?
363 "xvd" :
364 (vdev->type == XEN_BLOCK_VDEV_TYPE_HD) ?
365 "hd" :
366 "sd",
367 name, vdev->partition);
368 g_free(name);
369 break;
370 }
371 default:
372 error_setg(errp, "invalid vdev type");
373 return;
374 }
375
376 visit_type_str(v, name, &str, errp);
377 g_free(str);
378}
379
380static int vbd_name_to_disk(const char *name, const char **endp,
381 unsigned long *disk)
382{
383 unsigned int n = 0;
384
385 while (*name != '\0') {
386 if (!g_ascii_isalpha(*name) || !g_ascii_islower(*name)) {
387 break;
388 }
389
390 n *= 26;
391 n += *name++ - 'a' + 1;
392 }
393 *endp = name;
394
395 if (!n) {
396 return -1;
397 }
398
399 *disk = n - 1;
400
401 return 0;
402}
403
404static void xen_block_set_vdev(Object *obj, Visitor *v, const char *name,
405 void *opaque, Error **errp)
406{
407 DeviceState *dev = DEVICE(obj);
408 Property *prop = opaque;
409 XenBlockVdev *vdev = qdev_get_prop_ptr(dev, prop);
410 Error *local_err = NULL;
411 char *str, *p;
412 const char *end;
413
414 if (dev->realized) {
415 qdev_prop_set_after_realize(dev, name, errp);
416 return;
417 }
418
419 visit_type_str(v, name, &str, &local_err);
420 if (local_err) {
421 error_propagate(errp, local_err);
422 return;
423 }
424
425 p = strchr(str, 'd');
426 if (!p) {
427 goto invalid;
428 }
429
430 *p++ = '\0';
431 if (*str == '\0') {
432 vdev->type = XEN_BLOCK_VDEV_TYPE_DP;
433 } else if (strcmp(str, "xv") == 0) {
434 vdev->type = XEN_BLOCK_VDEV_TYPE_XVD;
435 } else if (strcmp(str, "h") == 0) {
436 vdev->type = XEN_BLOCK_VDEV_TYPE_HD;
437 } else if (strcmp(str, "s") == 0) {
438 vdev->type = XEN_BLOCK_VDEV_TYPE_SD;
439 } else {
440 goto invalid;
441 }
442
443 if (vdev->type == XEN_BLOCK_VDEV_TYPE_DP) {
444 if (qemu_strtoul(p, &end, 10, &vdev->disk)) {
445 goto invalid;
446 }
447
448 if (*end == 'p') {
449 if (*(++end) == '\0') {
450 goto invalid;
451 }
452 }
453 } else {
454 if (vbd_name_to_disk(p, &end, &vdev->disk)) {
455 goto invalid;
456 }
457 }
458
459 if (*end != '\0') {
460 p = (char *)end;
461
462 if (qemu_strtoul(p, &end, 10, &vdev->partition)) {
463 goto invalid;
464 }
465
466 if (*end != '\0') {
467 goto invalid;
468 }
469 } else {
470 vdev->partition = 0;
471 }
472
473 switch (vdev->type) {
474 case XEN_BLOCK_VDEV_TYPE_DP:
475 case XEN_BLOCK_VDEV_TYPE_XVD:
476 if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) {
477 vdev->number = (202 << 8) | (vdev->disk << 4) |
478 vdev->partition;
479 } else if (vdev->disk < (1 << 20) && vdev->partition < (1 << 8)) {
480 vdev->number = (1 << 28) | (vdev->disk << 8) |
481 vdev->partition;
482 } else {
483 goto invalid;
484 }
485 break;
486
487 case XEN_BLOCK_VDEV_TYPE_HD:
488 if ((vdev->disk == 0 || vdev->disk == 1) &&
489 vdev->partition < (1 << 6)) {
490 vdev->number = (3 << 8) | (vdev->disk << 6) | vdev->partition;
491 } else if ((vdev->disk == 2 || vdev->disk == 3) &&
492 vdev->partition < (1 << 6)) {
493 vdev->number = (22 << 8) | ((vdev->disk - 2) << 6) |
494 vdev->partition;
495 } else {
496 goto invalid;
497 }
498 break;
499
500 case XEN_BLOCK_VDEV_TYPE_SD:
501 if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) {
502 vdev->number = (8 << 8) | (vdev->disk << 4) | vdev->partition;
503 } else {
504 goto invalid;
505 }
506 break;
507
508 default:
509 goto invalid;
510 }
511
512 g_free(str);
513 return;
514
515invalid:
516 error_setg(errp, "invalid virtual disk specifier");
517
518 vdev->type = XEN_BLOCK_VDEV_TYPE_INVALID;
519 g_free(str);
520}
521
522
523
524
525
526
527
528const PropertyInfo xen_block_prop_vdev = {
529 .name = "str",
530 .description = "Virtual Disk specifier: d*p*/xvd*/hd*/sd*",
531 .get = xen_block_get_vdev,
532 .set = xen_block_set_vdev,
533};
534
535static Property xen_block_props[] = {
536 DEFINE_PROP("vdev", XenBlockDevice, props.vdev,
537 xen_block_prop_vdev, XenBlockVdev),
538 DEFINE_BLOCK_PROPERTIES(XenBlockDevice, props.conf),
539 DEFINE_PROP_UINT32("max-ring-page-order", XenBlockDevice,
540 props.max_ring_page_order, 4),
541 DEFINE_PROP_LINK("iothread", XenBlockDevice, props.iothread,
542 TYPE_IOTHREAD, IOThread *),
543 DEFINE_PROP_END_OF_LIST()
544};
545
546static void xen_block_class_init(ObjectClass *class, void *data)
547{
548 DeviceClass *dev_class = DEVICE_CLASS(class);
549 XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class);
550
551 xendev_class->backend = "qdisk";
552 xendev_class->device = "vbd";
553 xendev_class->get_name = xen_block_get_name;
554 xendev_class->realize = xen_block_realize;
555 xendev_class->frontend_changed = xen_block_frontend_changed;
556 xendev_class->unrealize = xen_block_unrealize;
557
558 device_class_set_props(dev_class, xen_block_props);
559}
560
561static const TypeInfo xen_block_type_info = {
562 .name = TYPE_XEN_BLOCK_DEVICE,
563 .parent = TYPE_XEN_DEVICE,
564 .instance_size = sizeof(XenBlockDevice),
565 .abstract = true,
566 .class_size = sizeof(XenBlockDeviceClass),
567 .class_init = xen_block_class_init,
568};
569
570static void xen_disk_unrealize(XenBlockDevice *blockdev, Error **errp)
571{
572 trace_xen_disk_unrealize();
573}
574
575static void xen_disk_realize(XenBlockDevice *blockdev, Error **errp)
576{
577 BlockConf *conf = &blockdev->props.conf;
578
579 trace_xen_disk_realize();
580
581 blockdev->device_type = "disk";
582
583 if (!conf->blk) {
584 error_setg(errp, "drive property not set");
585 return;
586 }
587
588 blockdev->info = blk_is_read_only(conf->blk) ? VDISK_READONLY : 0;
589}
590
591static void xen_disk_class_init(ObjectClass *class, void *data)
592{
593 DeviceClass *dev_class = DEVICE_CLASS(class);
594 XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class);
595
596 blockdev_class->realize = xen_disk_realize;
597 blockdev_class->unrealize = xen_disk_unrealize;
598
599 dev_class->desc = "Xen Disk Device";
600}
601
602static const TypeInfo xen_disk_type_info = {
603 .name = TYPE_XEN_DISK_DEVICE,
604 .parent = TYPE_XEN_BLOCK_DEVICE,
605 .instance_size = sizeof(XenDiskDevice),
606 .class_init = xen_disk_class_init,
607};
608
609static void xen_cdrom_unrealize(XenBlockDevice *blockdev, Error **errp)
610{
611 trace_xen_cdrom_unrealize();
612}
613
614static void xen_cdrom_realize(XenBlockDevice *blockdev, Error **errp)
615{
616 BlockConf *conf = &blockdev->props.conf;
617
618 trace_xen_cdrom_realize();
619
620 blockdev->device_type = "cdrom";
621
622 if (!conf->blk) {
623 int rc;
624
625
626 conf->blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
627
628 rc = blk_attach_dev(conf->blk, DEVICE(blockdev));
629 if (!rc) {
630 error_setg_errno(errp, -rc, "failed to create drive");
631 return;
632 }
633 }
634
635 blockdev->info = VDISK_READONLY | VDISK_CDROM;
636}
637
638static void xen_cdrom_class_init(ObjectClass *class, void *data)
639{
640 DeviceClass *dev_class = DEVICE_CLASS(class);
641 XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class);
642
643 blockdev_class->realize = xen_cdrom_realize;
644 blockdev_class->unrealize = xen_cdrom_unrealize;
645
646 dev_class->desc = "Xen CD-ROM Device";
647}
648
649static const TypeInfo xen_cdrom_type_info = {
650 .name = TYPE_XEN_CDROM_DEVICE,
651 .parent = TYPE_XEN_BLOCK_DEVICE,
652 .instance_size = sizeof(XenCDRomDevice),
653 .class_init = xen_cdrom_class_init,
654};
655
656static void xen_block_register_types(void)
657{
658 type_register_static(&xen_block_type_info);
659 type_register_static(&xen_disk_type_info);
660 type_register_static(&xen_cdrom_type_info);
661}
662
663type_init(xen_block_register_types)
664
665static void xen_block_blockdev_del(const char *node_name, Error **errp)
666{
667 trace_xen_block_blockdev_del(node_name);
668
669 qmp_blockdev_del(node_name, errp);
670}
671
672static char *xen_block_blockdev_add(const char *id, QDict *qdict,
673 Error **errp)
674{
675 const char *driver = qdict_get_try_str(qdict, "driver");
676 BlockdevOptions *options = NULL;
677 Error *local_err = NULL;
678 char *node_name;
679 Visitor *v;
680
681 if (!driver) {
682 error_setg(errp, "no 'driver' parameter");
683 return NULL;
684 }
685
686 node_name = g_strdup_printf("%s-%s", id, driver);
687 qdict_put_str(qdict, "node-name", node_name);
688
689 trace_xen_block_blockdev_add(node_name);
690
691 v = qobject_input_visitor_new(QOBJECT(qdict));
692 visit_type_BlockdevOptions(v, NULL, &options, &local_err);
693 visit_free(v);
694
695 if (local_err) {
696 error_propagate(errp, local_err);
697 goto fail;
698 }
699
700 qmp_blockdev_add(options, &local_err);
701
702 if (local_err) {
703 error_propagate(errp, local_err);
704 goto fail;
705 }
706
707 qapi_free_BlockdevOptions(options);
708
709 return node_name;
710
711fail:
712 if (options) {
713 qapi_free_BlockdevOptions(options);
714 }
715 g_free(node_name);
716
717 return NULL;
718}
719
720static void xen_block_drive_destroy(XenBlockDrive *drive, Error **errp)
721{
722 char *node_name = drive->node_name;
723
724 if (node_name) {
725 Error *local_err = NULL;
726
727 xen_block_blockdev_del(node_name, &local_err);
728 if (local_err) {
729 error_propagate(errp, local_err);
730 return;
731 }
732 g_free(node_name);
733 drive->node_name = NULL;
734 }
735 g_free(drive->id);
736 g_free(drive);
737}
738
739static XenBlockDrive *xen_block_drive_create(const char *id,
740 const char *device_type,
741 QDict *opts, Error **errp)
742{
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");
747 char *driver = NULL;
748 char *filename = NULL;
749 XenBlockDrive *drive = NULL;
750 Error *local_err = NULL;
751 QDict *file_layer;
752 QDict *driver_layer;
753
754 if (params) {
755 char **v = g_strsplit(params, ":", 2);
756
757 if (v[1] == NULL) {
758 filename = g_strdup(v[0]);
759 driver = g_strdup("raw");
760 } else {
761 if (strcmp(v[0], "aio") == 0) {
762 driver = g_strdup("raw");
763 } else if (strcmp(v[0], "vhd") == 0) {
764 driver = g_strdup("vpc");
765 } else {
766 driver = g_strdup(v[0]);
767 }
768 filename = g_strdup(v[1]);
769 }
770
771 g_strfreev(v);
772 } else {
773 error_setg(errp, "no params");
774 goto done;
775 }
776
777 assert(filename);
778 assert(driver);
779
780 drive = g_new0(XenBlockDrive, 1);
781 drive->id = g_strdup(id);
782
783 file_layer = qdict_new();
784 driver_layer = qdict_new();
785
786 qdict_put_str(file_layer, "driver", "file");
787 qdict_put_str(file_layer, "filename", filename);
788 g_free(filename);
789
790 if (mode && *mode != 'w') {
791 qdict_put_bool(file_layer, "read-only", true);
792 }
793
794 if (direct_io_safe) {
795 unsigned long value;
796
797 if (!qemu_strtoul(direct_io_safe, NULL, 2, &value) && !!value) {
798 QDict *cache_qdict = qdict_new();
799
800 qdict_put_bool(cache_qdict, "direct", true);
801 qdict_put(file_layer, "cache", cache_qdict);
802
803 qdict_put_str(file_layer, "aio", "native");
804 }
805 }
806
807 if (discard_enable) {
808 unsigned long value;
809
810 if (!qemu_strtoul(discard_enable, NULL, 2, &value) && !!value) {
811 qdict_put_str(file_layer, "discard", "unmap");
812 qdict_put_str(driver_layer, "discard", "unmap");
813 }
814 }
815
816
817
818
819
820 qdict_put_str(file_layer, "locking", "off");
821
822 qdict_put_str(driver_layer, "driver", driver);
823 g_free(driver);
824
825 qdict_put(driver_layer, "file", file_layer);
826
827 g_assert(!drive->node_name);
828 drive->node_name = xen_block_blockdev_add(drive->id, driver_layer,
829 &local_err);
830
831 qobject_unref(driver_layer);
832
833done:
834 if (local_err) {
835 error_propagate(errp, local_err);
836 xen_block_drive_destroy(drive, NULL);
837 return NULL;
838 }
839
840 return drive;
841}
842
843static const char *xen_block_drive_get_node_name(XenBlockDrive *drive)
844{
845 return drive->node_name ? drive->node_name : "";
846}
847
848static void xen_block_iothread_destroy(XenBlockIOThread *iothread,
849 Error **errp)
850{
851 qmp_object_del(iothread->id, errp);
852
853 g_free(iothread->id);
854 g_free(iothread);
855}
856
857static XenBlockIOThread *xen_block_iothread_create(const char *id,
858 Error **errp)
859{
860 XenBlockIOThread *iothread = g_new(XenBlockIOThread, 1);
861 Error *local_err = NULL;
862 QDict *opts;
863 QObject *ret_data = NULL;
864
865 iothread->id = g_strdup(id);
866
867 opts = qdict_new();
868 qdict_put_str(opts, "qom-type", TYPE_IOTHREAD);
869 qdict_put_str(opts, "id", id);
870 qmp_object_add(opts, &ret_data, &local_err);
871 qobject_unref(opts);
872 qobject_unref(ret_data);
873
874 if (local_err) {
875 error_propagate(errp, local_err);
876
877 g_free(iothread->id);
878 g_free(iothread);
879 return NULL;
880 }
881
882 return iothread;
883}
884
885static void xen_block_device_create(XenBackendInstance *backend,
886 QDict *opts, Error **errp)
887{
888 XenBus *xenbus = xen_backend_get_bus(backend);
889 const char *name = xen_backend_get_name(backend);
890 unsigned long number;
891 const char *vdev, *device_type;
892 XenBlockDrive *drive = NULL;
893 XenBlockIOThread *iothread = NULL;
894 XenDevice *xendev = NULL;
895 Error *local_err = NULL;
896 const char *type;
897 XenBlockDevice *blockdev;
898
899 if (qemu_strtoul(name, NULL, 10, &number)) {
900 error_setg(errp, "failed to parse name '%s'", name);
901 goto fail;
902 }
903
904 trace_xen_block_device_create(number);
905
906 vdev = qdict_get_try_str(opts, "dev");
907 if (!vdev) {
908 error_setg(errp, "no dev parameter");
909 goto fail;
910 }
911
912 device_type = qdict_get_try_str(opts, "device-type");
913 if (!device_type) {
914 error_setg(errp, "no device-type parameter");
915 goto fail;
916 }
917
918 if (!strcmp(device_type, "disk")) {
919 type = TYPE_XEN_DISK_DEVICE;
920 } else if (!strcmp(device_type, "cdrom")) {
921 type = TYPE_XEN_CDROM_DEVICE;
922 } else {
923 error_setg(errp, "invalid device-type parameter '%s'", device_type);
924 goto fail;
925 }
926
927 drive = xen_block_drive_create(vdev, device_type, opts, &local_err);
928 if (!drive) {
929 error_propagate_prepend(errp, local_err, "failed to create drive: ");
930 goto fail;
931 }
932
933 iothread = xen_block_iothread_create(vdev, &local_err);
934 if (local_err) {
935 error_propagate_prepend(errp, local_err,
936 "failed to create iothread: ");
937 goto fail;
938 }
939
940 xendev = XEN_DEVICE(qdev_create(BUS(xenbus), type));
941 blockdev = XEN_BLOCK_DEVICE(xendev);
942
943 object_property_set_str(OBJECT(xendev), vdev, "vdev", &local_err);
944 if (local_err) {
945 error_propagate_prepend(errp, local_err, "failed to set 'vdev': ");
946 goto fail;
947 }
948
949 object_property_set_str(OBJECT(xendev),
950 xen_block_drive_get_node_name(drive), "drive",
951 &local_err);
952 if (local_err) {
953 error_propagate_prepend(errp, local_err, "failed to set 'drive': ");
954 goto fail;
955 }
956
957 object_property_set_str(OBJECT(xendev), iothread->id, "iothread",
958 &local_err);
959 if (local_err) {
960 error_propagate_prepend(errp, local_err,
961 "failed to set 'iothread': ");
962 goto fail;
963 }
964
965 blockdev->iothread = iothread;
966 blockdev->drive = drive;
967
968 object_property_set_bool(OBJECT(xendev), true, "realized", &local_err);
969 if (local_err) {
970 error_propagate_prepend(errp, local_err,
971 "realization of device %s failed: ",
972 type);
973 goto fail;
974 }
975
976 xen_backend_set_device(backend, xendev);
977 return;
978
979fail:
980 if (xendev) {
981 object_unparent(OBJECT(xendev));
982 }
983
984 if (iothread) {
985 xen_block_iothread_destroy(iothread, NULL);
986 }
987
988 if (drive) {
989 xen_block_drive_destroy(drive, NULL);
990 }
991}
992
993static void xen_block_device_destroy(XenBackendInstance *backend,
994 Error **errp)
995{
996 XenDevice *xendev = xen_backend_get_device(backend);
997 XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
998 XenBlockVdev *vdev = &blockdev->props.vdev;
999 XenBlockDrive *drive = blockdev->drive;
1000 XenBlockIOThread *iothread = blockdev->iothread;
1001 Error *local_err = NULL;
1002
1003 trace_xen_block_device_destroy(vdev->number);
1004
1005 object_unparent(OBJECT(xendev));
1006
1007 if (iothread) {
1008 xen_block_iothread_destroy(iothread, &local_err);
1009 if (local_err) {
1010 error_propagate_prepend(errp, local_err,
1011 "failed to destroy iothread: ");
1012 return;
1013 }
1014 }
1015
1016 if (drive) {
1017 xen_block_drive_destroy(drive, &local_err);
1018 if (local_err) {
1019 error_propagate_prepend(errp, local_err,
1020 "failed to destroy drive: ");
1021 return;
1022 }
1023 }
1024}
1025
1026static const XenBackendInfo xen_block_backend_info = {
1027 .type = "qdisk",
1028 .create = xen_block_device_create,
1029 .destroy = xen_block_device_destroy,
1030};
1031
1032static void xen_block_register_backend(void)
1033{
1034 xen_backend_register(&xen_block_backend_info);
1035}
1036
1037xen_backend_init(xen_block_register_backend);
1038
