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