hw/block/xen-block.c

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