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