1 /* 2 * QEMU host block devices 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or 7 * later. See the COPYING file in the top-level directory. 8 */ 9 10 #include "blockdev.h" 11 #include "hw/block-common.h" 12 #include "blockjob.h" 13 #include "monitor.h" 14 #include "qerror.h" 15 #include "qemu-option.h" 16 #include "qemu-config.h" 17 #include "qemu-objects.h" 18 #include "sysemu.h" 19 #include "block_int.h" 20 #include "qmp-commands.h" 21 #include "trace.h" 22 #include "arch_init.h" 23 24 static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives); 25 26 static const char *const if_name[IF_COUNT] = { 27 [IF_NONE] = "none", 28 [IF_IDE] = "ide", 29 [IF_SCSI] = "scsi", 30 [IF_FLOPPY] = "floppy", 31 [IF_PFLASH] = "pflash", 32 [IF_MTD] = "mtd", 33 [IF_SD] = "sd", 34 [IF_VIRTIO] = "virtio", 35 [IF_XEN] = "xen", 36 }; 37 38 static const int if_max_devs[IF_COUNT] = { 39 /* 40 * Do not change these numbers! They govern how drive option 41 * index maps to unit and bus. That mapping is ABI. 42 * 43 * All controllers used to imlement if=T drives need to support 44 * if_max_devs[T] units, for any T with if_max_devs[T] != 0. 45 * Otherwise, some index values map to "impossible" bus, unit 46 * values. 47 * 48 * For instance, if you change [IF_SCSI] to 255, -drive 49 * if=scsi,index=12 no longer means bus=1,unit=5, but 50 * bus=0,unit=12. With an lsi53c895a controller (7 units max), 51 * the drive can't be set up. Regression. 52 */ 53 [IF_IDE] = 2, 54 [IF_SCSI] = 7, 55 }; 56 57 /* 58 * We automatically delete the drive when a device using it gets 59 * unplugged. Questionable feature, but we can't just drop it. 60 * Device models call blockdev_mark_auto_del() to schedule the 61 * automatic deletion, and generic qdev code calls blockdev_auto_del() 62 * when deletion is actually safe. 63 */ 64 void blockdev_mark_auto_del(BlockDriverState *bs) 65 { 66 DriveInfo *dinfo = drive_get_by_blockdev(bs); 67 68 if (bs->job) { 69 block_job_cancel(bs->job); 70 } 71 if (dinfo) { 72 dinfo->auto_del = 1; 73 } 74 } 75 76 void blockdev_auto_del(BlockDriverState *bs) 77 { 78 DriveInfo *dinfo = drive_get_by_blockdev(bs); 79 80 if (dinfo && dinfo->auto_del) { 81 drive_put_ref(dinfo); 82 } 83 } 84 85 static int drive_index_to_bus_id(BlockInterfaceType type, int index) 86 { 87 int max_devs = if_max_devs[type]; 88 return max_devs ? index / max_devs : 0; 89 } 90 91 static int drive_index_to_unit_id(BlockInterfaceType type, int index) 92 { 93 int max_devs = if_max_devs[type]; 94 return max_devs ? index % max_devs : index; 95 } 96 97 QemuOpts *drive_def(const char *optstr) 98 { 99 return qemu_opts_parse(qemu_find_opts("drive"), optstr, 0); 100 } 101 102 QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file, 103 const char *optstr) 104 { 105 QemuOpts *opts; 106 char buf[32]; 107 108 opts = drive_def(optstr); 109 if (!opts) { 110 return NULL; 111 } 112 if (type != IF_DEFAULT) { 113 qemu_opt_set(opts, "if", if_name[type]); 114 } 115 if (index >= 0) { 116 snprintf(buf, sizeof(buf), "%d", index); 117 qemu_opt_set(opts, "index", buf); 118 } 119 if (file) 120 qemu_opt_set(opts, "file", file); 121 return opts; 122 } 123 124 DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit) 125 { 126 DriveInfo *dinfo; 127 128 /* seek interface, bus and unit */ 129 130 QTAILQ_FOREACH(dinfo, &drives, next) { 131 if (dinfo->type == type && 132 dinfo->bus == bus && 133 dinfo->unit == unit) 134 return dinfo; 135 } 136 137 return NULL; 138 } 139 140 DriveInfo *drive_get_by_index(BlockInterfaceType type, int index) 141 { 142 return drive_get(type, 143 drive_index_to_bus_id(type, index), 144 drive_index_to_unit_id(type, index)); 145 } 146 147 int drive_get_max_bus(BlockInterfaceType type) 148 { 149 int max_bus; 150 DriveInfo *dinfo; 151 152 max_bus = -1; 153 QTAILQ_FOREACH(dinfo, &drives, next) { 154 if(dinfo->type == type && 155 dinfo->bus > max_bus) 156 max_bus = dinfo->bus; 157 } 158 return max_bus; 159 } 160 161 /* Get a block device. This should only be used for single-drive devices 162 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the 163 appropriate bus. */ 164 DriveInfo *drive_get_next(BlockInterfaceType type) 165 { 166 static int next_block_unit[IF_COUNT]; 167 168 return drive_get(type, 0, next_block_unit[type]++); 169 } 170 171 DriveInfo *drive_get_by_blockdev(BlockDriverState *bs) 172 { 173 DriveInfo *dinfo; 174 175 QTAILQ_FOREACH(dinfo, &drives, next) { 176 if (dinfo->bdrv == bs) { 177 return dinfo; 178 } 179 } 180 return NULL; 181 } 182 183 static void bdrv_format_print(void *opaque, const char *name) 184 { 185 error_printf(" %s", name); 186 } 187 188 static void drive_uninit(DriveInfo *dinfo) 189 { 190 qemu_opts_del(dinfo->opts); 191 bdrv_delete(dinfo->bdrv); 192 g_free(dinfo->id); 193 QTAILQ_REMOVE(&drives, dinfo, next); 194 g_free(dinfo); 195 } 196 197 void drive_put_ref(DriveInfo *dinfo) 198 { 199 assert(dinfo->refcount); 200 if (--dinfo->refcount == 0) { 201 drive_uninit(dinfo); 202 } 203 } 204 205 void drive_get_ref(DriveInfo *dinfo) 206 { 207 dinfo->refcount++; 208 } 209 210 typedef struct { 211 QEMUBH *bh; 212 DriveInfo *dinfo; 213 } DrivePutRefBH; 214 215 static void drive_put_ref_bh(void *opaque) 216 { 217 DrivePutRefBH *s = opaque; 218 219 drive_put_ref(s->dinfo); 220 qemu_bh_delete(s->bh); 221 g_free(s); 222 } 223 224 /* 225 * Release a drive reference in a BH 226 * 227 * It is not possible to use drive_put_ref() from a callback function when the 228 * callers still need the drive. In such cases we schedule a BH to release the 229 * reference. 230 */ 231 static void drive_put_ref_bh_schedule(DriveInfo *dinfo) 232 { 233 DrivePutRefBH *s; 234 235 s = g_new(DrivePutRefBH, 1); 236 s->bh = qemu_bh_new(drive_put_ref_bh, s); 237 s->dinfo = dinfo; 238 qemu_bh_schedule(s->bh); 239 } 240 241 static int parse_block_error_action(const char *buf, bool is_read) 242 { 243 if (!strcmp(buf, "ignore")) { 244 return BLOCKDEV_ON_ERROR_IGNORE; 245 } else if (!is_read && !strcmp(buf, "enospc")) { 246 return BLOCKDEV_ON_ERROR_ENOSPC; 247 } else if (!strcmp(buf, "stop")) { 248 return BLOCKDEV_ON_ERROR_STOP; 249 } else if (!strcmp(buf, "report")) { 250 return BLOCKDEV_ON_ERROR_REPORT; 251 } else { 252 error_report("'%s' invalid %s error action", 253 buf, is_read ? "read" : "write"); 254 return -1; 255 } 256 } 257 258 static bool do_check_io_limits(BlockIOLimit *io_limits) 259 { 260 bool bps_flag; 261 bool iops_flag; 262 263 assert(io_limits); 264 265 bps_flag = (io_limits->bps[BLOCK_IO_LIMIT_TOTAL] != 0) 266 && ((io_limits->bps[BLOCK_IO_LIMIT_READ] != 0) 267 || (io_limits->bps[BLOCK_IO_LIMIT_WRITE] != 0)); 268 iops_flag = (io_limits->iops[BLOCK_IO_LIMIT_TOTAL] != 0) 269 && ((io_limits->iops[BLOCK_IO_LIMIT_READ] != 0) 270 || (io_limits->iops[BLOCK_IO_LIMIT_WRITE] != 0)); 271 if (bps_flag || iops_flag) { 272 return false; 273 } 274 275 return true; 276 } 277 278 DriveInfo *drive_init(QemuOpts *opts, int default_to_scsi) 279 { 280 const char *buf; 281 const char *file = NULL; 282 const char *serial; 283 const char *mediastr = ""; 284 BlockInterfaceType type; 285 enum { MEDIA_DISK, MEDIA_CDROM } media; 286 int bus_id, unit_id; 287 int cyls, heads, secs, translation; 288 BlockDriver *drv = NULL; 289 int max_devs; 290 int index; 291 int ro = 0; 292 int bdrv_flags = 0; 293 int on_read_error, on_write_error; 294 const char *devaddr; 295 DriveInfo *dinfo; 296 BlockIOLimit io_limits; 297 int snapshot = 0; 298 bool copy_on_read; 299 int ret; 300 301 translation = BIOS_ATA_TRANSLATION_AUTO; 302 media = MEDIA_DISK; 303 304 /* extract parameters */ 305 bus_id = qemu_opt_get_number(opts, "bus", 0); 306 unit_id = qemu_opt_get_number(opts, "unit", -1); 307 index = qemu_opt_get_number(opts, "index", -1); 308 309 cyls = qemu_opt_get_number(opts, "cyls", 0); 310 heads = qemu_opt_get_number(opts, "heads", 0); 311 secs = qemu_opt_get_number(opts, "secs", 0); 312 313 snapshot = qemu_opt_get_bool(opts, "snapshot", 0); 314 ro = qemu_opt_get_bool(opts, "readonly", 0); 315 copy_on_read = qemu_opt_get_bool(opts, "copy-on-read", false); 316 317 file = qemu_opt_get(opts, "file"); 318 serial = qemu_opt_get(opts, "serial"); 319 320 if ((buf = qemu_opt_get(opts, "if")) != NULL) { 321 for (type = 0; type < IF_COUNT && strcmp(buf, if_name[type]); type++) 322 ; 323 if (type == IF_COUNT) { 324 error_report("unsupported bus type '%s'", buf); 325 return NULL; 326 } 327 } else { 328 type = default_to_scsi ? IF_SCSI : IF_IDE; 329 } 330 331 max_devs = if_max_devs[type]; 332 333 if (cyls || heads || secs) { 334 if (cyls < 1) { 335 error_report("invalid physical cyls number"); 336 return NULL; 337 } 338 if (heads < 1) { 339 error_report("invalid physical heads number"); 340 return NULL; 341 } 342 if (secs < 1) { 343 error_report("invalid physical secs number"); 344 return NULL; 345 } 346 } 347 348 if ((buf = qemu_opt_get(opts, "trans")) != NULL) { 349 if (!cyls) { 350 error_report("'%s' trans must be used with cyls, heads and secs", 351 buf); 352 return NULL; 353 } 354 if (!strcmp(buf, "none")) 355 translation = BIOS_ATA_TRANSLATION_NONE; 356 else if (!strcmp(buf, "lba")) 357 translation = BIOS_ATA_TRANSLATION_LBA; 358 else if (!strcmp(buf, "auto")) 359 translation = BIOS_ATA_TRANSLATION_AUTO; 360 else { 361 error_report("'%s' invalid translation type", buf); 362 return NULL; 363 } 364 } 365 366 if ((buf = qemu_opt_get(opts, "media")) != NULL) { 367 if (!strcmp(buf, "disk")) { 368 media = MEDIA_DISK; 369 } else if (!strcmp(buf, "cdrom")) { 370 if (cyls || secs || heads) { 371 error_report("CHS can't be set with media=%s", buf); 372 return NULL; 373 } 374 media = MEDIA_CDROM; 375 } else { 376 error_report("'%s' invalid media", buf); 377 return NULL; 378 } 379 } 380 381 bdrv_flags |= BDRV_O_CACHE_WB; 382 if ((buf = qemu_opt_get(opts, "cache")) != NULL) { 383 if (bdrv_parse_cache_flags(buf, &bdrv_flags) != 0) { 384 error_report("invalid cache option"); 385 return NULL; 386 } 387 } 388 389 #ifdef CONFIG_LINUX_AIO 390 if ((buf = qemu_opt_get(opts, "aio")) != NULL) { 391 if (!strcmp(buf, "native")) { 392 bdrv_flags |= BDRV_O_NATIVE_AIO; 393 } else if (!strcmp(buf, "threads")) { 394 /* this is the default */ 395 } else { 396 error_report("invalid aio option"); 397 return NULL; 398 } 399 } 400 #endif 401 402 if ((buf = qemu_opt_get(opts, "format")) != NULL) { 403 if (is_help_option(buf)) { 404 error_printf("Supported formats:"); 405 bdrv_iterate_format(bdrv_format_print, NULL); 406 error_printf("\n"); 407 return NULL; 408 } 409 drv = bdrv_find_whitelisted_format(buf); 410 if (!drv) { 411 error_report("'%s' invalid format", buf); 412 return NULL; 413 } 414 } 415 416 /* disk I/O throttling */ 417 io_limits.bps[BLOCK_IO_LIMIT_TOTAL] = 418 qemu_opt_get_number(opts, "bps", 0); 419 io_limits.bps[BLOCK_IO_LIMIT_READ] = 420 qemu_opt_get_number(opts, "bps_rd", 0); 421 io_limits.bps[BLOCK_IO_LIMIT_WRITE] = 422 qemu_opt_get_number(opts, "bps_wr", 0); 423 io_limits.iops[BLOCK_IO_LIMIT_TOTAL] = 424 qemu_opt_get_number(opts, "iops", 0); 425 io_limits.iops[BLOCK_IO_LIMIT_READ] = 426 qemu_opt_get_number(opts, "iops_rd", 0); 427 io_limits.iops[BLOCK_IO_LIMIT_WRITE] = 428 qemu_opt_get_number(opts, "iops_wr", 0); 429 430 if (!do_check_io_limits(&io_limits)) { 431 error_report("bps(iops) and bps_rd/bps_wr(iops_rd/iops_wr) " 432 "cannot be used at the same time"); 433 return NULL; 434 } 435 436 on_write_error = BLOCKDEV_ON_ERROR_ENOSPC; 437 if ((buf = qemu_opt_get(opts, "werror")) != NULL) { 438 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && type != IF_NONE) { 439 error_report("werror is not supported by this bus type"); 440 return NULL; 441 } 442 443 on_write_error = parse_block_error_action(buf, 0); 444 if (on_write_error < 0) { 445 return NULL; 446 } 447 } 448 449 on_read_error = BLOCKDEV_ON_ERROR_REPORT; 450 if ((buf = qemu_opt_get(opts, "rerror")) != NULL) { 451 if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI && type != IF_NONE) { 452 error_report("rerror is not supported by this bus type"); 453 return NULL; 454 } 455 456 on_read_error = parse_block_error_action(buf, 1); 457 if (on_read_error < 0) { 458 return NULL; 459 } 460 } 461 462 if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) { 463 if (type != IF_VIRTIO) { 464 error_report("addr is not supported by this bus type"); 465 return NULL; 466 } 467 } 468 469 /* compute bus and unit according index */ 470 471 if (index != -1) { 472 if (bus_id != 0 || unit_id != -1) { 473 error_report("index cannot be used with bus and unit"); 474 return NULL; 475 } 476 bus_id = drive_index_to_bus_id(type, index); 477 unit_id = drive_index_to_unit_id(type, index); 478 } 479 480 /* if user doesn't specify a unit_id, 481 * try to find the first free 482 */ 483 484 if (unit_id == -1) { 485 unit_id = 0; 486 while (drive_get(type, bus_id, unit_id) != NULL) { 487 unit_id++; 488 if (max_devs && unit_id >= max_devs) { 489 unit_id -= max_devs; 490 bus_id++; 491 } 492 } 493 } 494 495 /* check unit id */ 496 497 if (max_devs && unit_id >= max_devs) { 498 error_report("unit %d too big (max is %d)", 499 unit_id, max_devs - 1); 500 return NULL; 501 } 502 503 /* 504 * catch multiple definitions 505 */ 506 507 if (drive_get(type, bus_id, unit_id) != NULL) { 508 error_report("drive with bus=%d, unit=%d (index=%d) exists", 509 bus_id, unit_id, index); 510 return NULL; 511 } 512 513 /* init */ 514 515 dinfo = g_malloc0(sizeof(*dinfo)); 516 if ((buf = qemu_opts_id(opts)) != NULL) { 517 dinfo->id = g_strdup(buf); 518 } else { 519 /* no id supplied -> create one */ 520 dinfo->id = g_malloc0(32); 521 if (type == IF_IDE || type == IF_SCSI) 522 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd"; 523 if (max_devs) 524 snprintf(dinfo->id, 32, "%s%i%s%i", 525 if_name[type], bus_id, mediastr, unit_id); 526 else 527 snprintf(dinfo->id, 32, "%s%s%i", 528 if_name[type], mediastr, unit_id); 529 } 530 dinfo->bdrv = bdrv_new(dinfo->id); 531 dinfo->bdrv->open_flags = snapshot ? BDRV_O_SNAPSHOT : 0; 532 dinfo->bdrv->read_only = ro; 533 dinfo->devaddr = devaddr; 534 dinfo->type = type; 535 dinfo->bus = bus_id; 536 dinfo->unit = unit_id; 537 dinfo->cyls = cyls; 538 dinfo->heads = heads; 539 dinfo->secs = secs; 540 dinfo->trans = translation; 541 dinfo->opts = opts; 542 dinfo->refcount = 1; 543 dinfo->serial = serial; 544 QTAILQ_INSERT_TAIL(&drives, dinfo, next); 545 546 bdrv_set_on_error(dinfo->bdrv, on_read_error, on_write_error); 547 548 /* disk I/O throttling */ 549 bdrv_set_io_limits(dinfo->bdrv, &io_limits); 550 551 switch(type) { 552 case IF_IDE: 553 case IF_SCSI: 554 case IF_XEN: 555 case IF_NONE: 556 dinfo->media_cd = media == MEDIA_CDROM; 557 break; 558 case IF_SD: 559 case IF_FLOPPY: 560 case IF_PFLASH: 561 case IF_MTD: 562 break; 563 case IF_VIRTIO: 564 /* add virtio block device */ 565 opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0, NULL); 566 if (arch_type == QEMU_ARCH_S390X) { 567 qemu_opt_set(opts, "driver", "virtio-blk-s390"); 568 } else { 569 qemu_opt_set(opts, "driver", "virtio-blk-pci"); 570 } 571 qemu_opt_set(opts, "drive", dinfo->id); 572 if (devaddr) 573 qemu_opt_set(opts, "addr", devaddr); 574 break; 575 default: 576 abort(); 577 } 578 if (!file || !*file) { 579 return dinfo; 580 } 581 if (snapshot) { 582 /* always use cache=unsafe with snapshot */ 583 bdrv_flags &= ~BDRV_O_CACHE_MASK; 584 bdrv_flags |= (BDRV_O_SNAPSHOT|BDRV_O_CACHE_WB|BDRV_O_NO_FLUSH); 585 } 586 587 if (copy_on_read) { 588 bdrv_flags |= BDRV_O_COPY_ON_READ; 589 } 590 591 if (runstate_check(RUN_STATE_INMIGRATE)) { 592 bdrv_flags |= BDRV_O_INCOMING; 593 } 594 595 if (media == MEDIA_CDROM) { 596 /* CDROM is fine for any interface, don't check. */ 597 ro = 1; 598 } else if (ro == 1) { 599 if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY && 600 type != IF_NONE && type != IF_PFLASH) { 601 error_report("readonly not supported by this bus type"); 602 goto err; 603 } 604 } 605 606 bdrv_flags |= ro ? 0 : BDRV_O_RDWR; 607 608 if (ro && copy_on_read) { 609 error_report("warning: disabling copy_on_read on readonly drive"); 610 } 611 612 ret = bdrv_open(dinfo->bdrv, file, bdrv_flags, drv); 613 if (ret < 0) { 614 error_report("could not open disk image %s: %s", 615 file, strerror(-ret)); 616 goto err; 617 } 618 619 if (bdrv_key_required(dinfo->bdrv)) 620 autostart = 0; 621 return dinfo; 622 623 err: 624 bdrv_delete(dinfo->bdrv); 625 g_free(dinfo->id); 626 QTAILQ_REMOVE(&drives, dinfo, next); 627 g_free(dinfo); 628 return NULL; 629 } 630 631 void do_commit(Monitor *mon, const QDict *qdict) 632 { 633 const char *device = qdict_get_str(qdict, "device"); 634 BlockDriverState *bs; 635 int ret; 636 637 if (!strcmp(device, "all")) { 638 ret = bdrv_commit_all(); 639 if (ret == -EBUSY) { 640 qerror_report(QERR_DEVICE_IN_USE, device); 641 return; 642 } 643 } else { 644 bs = bdrv_find(device); 645 if (!bs) { 646 qerror_report(QERR_DEVICE_NOT_FOUND, device); 647 return; 648 } 649 ret = bdrv_commit(bs); 650 if (ret == -EBUSY) { 651 qerror_report(QERR_DEVICE_IN_USE, device); 652 return; 653 } 654 } 655 } 656 657 static void blockdev_do_action(int kind, void *data, Error **errp) 658 { 659 BlockdevAction action; 660 BlockdevActionList list; 661 662 action.kind = kind; 663 action.data = data; 664 list.value = &action; 665 list.next = NULL; 666 qmp_transaction(&list, errp); 667 } 668 669 void qmp_blockdev_snapshot_sync(const char *device, const char *snapshot_file, 670 bool has_format, const char *format, 671 bool has_mode, enum NewImageMode mode, 672 Error **errp) 673 { 674 BlockdevSnapshot snapshot = { 675 .device = (char *) device, 676 .snapshot_file = (char *) snapshot_file, 677 .has_format = has_format, 678 .format = (char *) format, 679 .has_mode = has_mode, 680 .mode = mode, 681 }; 682 blockdev_do_action(BLOCKDEV_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC, &snapshot, 683 errp); 684 } 685 686 687 /* New and old BlockDriverState structs for group snapshots */ 688 typedef struct BlkTransactionStates { 689 BlockDriverState *old_bs; 690 BlockDriverState *new_bs; 691 QSIMPLEQ_ENTRY(BlkTransactionStates) entry; 692 } BlkTransactionStates; 693 694 /* 695 * 'Atomic' group snapshots. The snapshots are taken as a set, and if any fail 696 * then we do not pivot any of the devices in the group, and abandon the 697 * snapshots 698 */ 699 void qmp_transaction(BlockdevActionList *dev_list, Error **errp) 700 { 701 int ret = 0; 702 BlockdevActionList *dev_entry = dev_list; 703 BlkTransactionStates *states, *next; 704 705 QSIMPLEQ_HEAD(snap_bdrv_states, BlkTransactionStates) snap_bdrv_states; 706 QSIMPLEQ_INIT(&snap_bdrv_states); 707 708 /* drain all i/o before any snapshots */ 709 bdrv_drain_all(); 710 711 /* We don't do anything in this loop that commits us to the snapshot */ 712 while (NULL != dev_entry) { 713 BlockdevAction *dev_info = NULL; 714 BlockDriver *proto_drv; 715 BlockDriver *drv; 716 int flags; 717 enum NewImageMode mode; 718 const char *new_image_file; 719 const char *device; 720 const char *format = "qcow2"; 721 722 dev_info = dev_entry->value; 723 dev_entry = dev_entry->next; 724 725 states = g_malloc0(sizeof(BlkTransactionStates)); 726 QSIMPLEQ_INSERT_TAIL(&snap_bdrv_states, states, entry); 727 728 switch (dev_info->kind) { 729 case BLOCKDEV_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC: 730 device = dev_info->blockdev_snapshot_sync->device; 731 if (!dev_info->blockdev_snapshot_sync->has_mode) { 732 dev_info->blockdev_snapshot_sync->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS; 733 } 734 new_image_file = dev_info->blockdev_snapshot_sync->snapshot_file; 735 if (dev_info->blockdev_snapshot_sync->has_format) { 736 format = dev_info->blockdev_snapshot_sync->format; 737 } 738 mode = dev_info->blockdev_snapshot_sync->mode; 739 break; 740 default: 741 abort(); 742 } 743 744 drv = bdrv_find_format(format); 745 if (!drv) { 746 error_set(errp, QERR_INVALID_BLOCK_FORMAT, format); 747 goto delete_and_fail; 748 } 749 750 states->old_bs = bdrv_find(device); 751 if (!states->old_bs) { 752 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 753 goto delete_and_fail; 754 } 755 756 if (!bdrv_is_inserted(states->old_bs)) { 757 error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device); 758 goto delete_and_fail; 759 } 760 761 if (bdrv_in_use(states->old_bs)) { 762 error_set(errp, QERR_DEVICE_IN_USE, device); 763 goto delete_and_fail; 764 } 765 766 if (!bdrv_is_read_only(states->old_bs)) { 767 if (bdrv_flush(states->old_bs)) { 768 error_set(errp, QERR_IO_ERROR); 769 goto delete_and_fail; 770 } 771 } 772 773 flags = states->old_bs->open_flags; 774 775 proto_drv = bdrv_find_protocol(new_image_file); 776 if (!proto_drv) { 777 error_set(errp, QERR_INVALID_BLOCK_FORMAT, format); 778 goto delete_and_fail; 779 } 780 781 /* create new image w/backing file */ 782 if (mode != NEW_IMAGE_MODE_EXISTING) { 783 ret = bdrv_img_create(new_image_file, format, 784 states->old_bs->filename, 785 states->old_bs->drv->format_name, 786 NULL, -1, flags); 787 if (ret) { 788 error_set(errp, QERR_OPEN_FILE_FAILED, new_image_file); 789 goto delete_and_fail; 790 } 791 } 792 793 /* We will manually add the backing_hd field to the bs later */ 794 states->new_bs = bdrv_new(""); 795 ret = bdrv_open(states->new_bs, new_image_file, 796 flags | BDRV_O_NO_BACKING, drv); 797 if (ret != 0) { 798 error_set(errp, QERR_OPEN_FILE_FAILED, new_image_file); 799 goto delete_and_fail; 800 } 801 } 802 803 804 /* Now we are going to do the actual pivot. Everything up to this point 805 * is reversible, but we are committed at this point */ 806 QSIMPLEQ_FOREACH(states, &snap_bdrv_states, entry) { 807 /* This removes our old bs from the bdrv_states, and adds the new bs */ 808 bdrv_append(states->new_bs, states->old_bs); 809 /* We don't need (or want) to use the transactional 810 * bdrv_reopen_multiple() across all the entries at once, because we 811 * don't want to abort all of them if one of them fails the reopen */ 812 bdrv_reopen(states->new_bs, states->new_bs->open_flags & ~BDRV_O_RDWR, 813 NULL); 814 } 815 816 /* success */ 817 goto exit; 818 819 delete_and_fail: 820 /* 821 * failure, and it is all-or-none; abandon each new bs, and keep using 822 * the original bs for all images 823 */ 824 QSIMPLEQ_FOREACH(states, &snap_bdrv_states, entry) { 825 if (states->new_bs) { 826 bdrv_delete(states->new_bs); 827 } 828 } 829 exit: 830 QSIMPLEQ_FOREACH_SAFE(states, &snap_bdrv_states, entry, next) { 831 g_free(states); 832 } 833 } 834 835 836 static void eject_device(BlockDriverState *bs, int force, Error **errp) 837 { 838 if (bdrv_in_use(bs)) { 839 error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs)); 840 return; 841 } 842 if (!bdrv_dev_has_removable_media(bs)) { 843 error_set(errp, QERR_DEVICE_NOT_REMOVABLE, bdrv_get_device_name(bs)); 844 return; 845 } 846 847 if (bdrv_dev_is_medium_locked(bs) && !bdrv_dev_is_tray_open(bs)) { 848 bdrv_dev_eject_request(bs, force); 849 if (!force) { 850 error_set(errp, QERR_DEVICE_LOCKED, bdrv_get_device_name(bs)); 851 return; 852 } 853 } 854 855 bdrv_close(bs); 856 } 857 858 void qmp_eject(const char *device, bool has_force, bool force, Error **errp) 859 { 860 BlockDriverState *bs; 861 862 bs = bdrv_find(device); 863 if (!bs) { 864 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 865 return; 866 } 867 868 eject_device(bs, force, errp); 869 } 870 871 void qmp_block_passwd(const char *device, const char *password, Error **errp) 872 { 873 BlockDriverState *bs; 874 int err; 875 876 bs = bdrv_find(device); 877 if (!bs) { 878 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 879 return; 880 } 881 882 err = bdrv_set_key(bs, password); 883 if (err == -EINVAL) { 884 error_set(errp, QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs)); 885 return; 886 } else if (err < 0) { 887 error_set(errp, QERR_INVALID_PASSWORD); 888 return; 889 } 890 } 891 892 static void qmp_bdrv_open_encrypted(BlockDriverState *bs, const char *filename, 893 int bdrv_flags, BlockDriver *drv, 894 const char *password, Error **errp) 895 { 896 if (bdrv_open(bs, filename, bdrv_flags, drv) < 0) { 897 error_set(errp, QERR_OPEN_FILE_FAILED, filename); 898 return; 899 } 900 901 if (bdrv_key_required(bs)) { 902 if (password) { 903 if (bdrv_set_key(bs, password) < 0) { 904 error_set(errp, QERR_INVALID_PASSWORD); 905 } 906 } else { 907 error_set(errp, QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs), 908 bdrv_get_encrypted_filename(bs)); 909 } 910 } else if (password) { 911 error_set(errp, QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs)); 912 } 913 } 914 915 void qmp_change_blockdev(const char *device, const char *filename, 916 bool has_format, const char *format, Error **errp) 917 { 918 BlockDriverState *bs; 919 BlockDriver *drv = NULL; 920 int bdrv_flags; 921 Error *err = NULL; 922 923 bs = bdrv_find(device); 924 if (!bs) { 925 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 926 return; 927 } 928 929 if (format) { 930 drv = bdrv_find_whitelisted_format(format); 931 if (!drv) { 932 error_set(errp, QERR_INVALID_BLOCK_FORMAT, format); 933 return; 934 } 935 } 936 937 eject_device(bs, 0, &err); 938 if (error_is_set(&err)) { 939 error_propagate(errp, err); 940 return; 941 } 942 943 bdrv_flags = bdrv_is_read_only(bs) ? 0 : BDRV_O_RDWR; 944 bdrv_flags |= bdrv_is_snapshot(bs) ? BDRV_O_SNAPSHOT : 0; 945 946 qmp_bdrv_open_encrypted(bs, filename, bdrv_flags, drv, NULL, errp); 947 } 948 949 /* throttling disk I/O limits */ 950 void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, 951 int64_t bps_wr, int64_t iops, int64_t iops_rd, 952 int64_t iops_wr, Error **errp) 953 { 954 BlockIOLimit io_limits; 955 BlockDriverState *bs; 956 957 bs = bdrv_find(device); 958 if (!bs) { 959 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 960 return; 961 } 962 963 io_limits.bps[BLOCK_IO_LIMIT_TOTAL] = bps; 964 io_limits.bps[BLOCK_IO_LIMIT_READ] = bps_rd; 965 io_limits.bps[BLOCK_IO_LIMIT_WRITE] = bps_wr; 966 io_limits.iops[BLOCK_IO_LIMIT_TOTAL]= iops; 967 io_limits.iops[BLOCK_IO_LIMIT_READ] = iops_rd; 968 io_limits.iops[BLOCK_IO_LIMIT_WRITE]= iops_wr; 969 970 if (!do_check_io_limits(&io_limits)) { 971 error_set(errp, QERR_INVALID_PARAMETER_COMBINATION); 972 return; 973 } 974 975 bs->io_limits = io_limits; 976 bs->slice_time = BLOCK_IO_SLICE_TIME; 977 978 if (!bs->io_limits_enabled && bdrv_io_limits_enabled(bs)) { 979 bdrv_io_limits_enable(bs); 980 } else if (bs->io_limits_enabled && !bdrv_io_limits_enabled(bs)) { 981 bdrv_io_limits_disable(bs); 982 } else { 983 if (bs->block_timer) { 984 qemu_mod_timer(bs->block_timer, qemu_get_clock_ns(vm_clock)); 985 } 986 } 987 } 988 989 int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) 990 { 991 const char *id = qdict_get_str(qdict, "id"); 992 BlockDriverState *bs; 993 994 bs = bdrv_find(id); 995 if (!bs) { 996 qerror_report(QERR_DEVICE_NOT_FOUND, id); 997 return -1; 998 } 999 if (bdrv_in_use(bs)) { 1000 qerror_report(QERR_DEVICE_IN_USE, id); 1001 return -1; 1002 } 1003 1004 /* quiesce block driver; prevent further io */ 1005 bdrv_drain_all(); 1006 bdrv_flush(bs); 1007 bdrv_close(bs); 1008 1009 /* if we have a device attached to this BlockDriverState 1010 * then we need to make the drive anonymous until the device 1011 * can be removed. If this is a drive with no device backing 1012 * then we can just get rid of the block driver state right here. 1013 */ 1014 if (bdrv_get_attached_dev(bs)) { 1015 bdrv_make_anon(bs); 1016 } else { 1017 drive_uninit(drive_get_by_blockdev(bs)); 1018 } 1019 1020 return 0; 1021 } 1022 1023 void qmp_block_resize(const char *device, int64_t size, Error **errp) 1024 { 1025 BlockDriverState *bs; 1026 1027 bs = bdrv_find(device); 1028 if (!bs) { 1029 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 1030 return; 1031 } 1032 1033 if (size < 0) { 1034 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size"); 1035 return; 1036 } 1037 1038 switch (bdrv_truncate(bs, size)) { 1039 case 0: 1040 break; 1041 case -ENOMEDIUM: 1042 error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device); 1043 break; 1044 case -ENOTSUP: 1045 error_set(errp, QERR_UNSUPPORTED); 1046 break; 1047 case -EACCES: 1048 error_set(errp, QERR_DEVICE_IS_READ_ONLY, device); 1049 break; 1050 case -EBUSY: 1051 error_set(errp, QERR_DEVICE_IN_USE, device); 1052 break; 1053 default: 1054 error_set(errp, QERR_UNDEFINED_ERROR); 1055 break; 1056 } 1057 } 1058 1059 static void block_job_cb(void *opaque, int ret) 1060 { 1061 BlockDriverState *bs = opaque; 1062 QObject *obj; 1063 1064 trace_block_job_cb(bs, bs->job, ret); 1065 1066 assert(bs->job); 1067 obj = qobject_from_block_job(bs->job); 1068 if (ret < 0) { 1069 QDict *dict = qobject_to_qdict(obj); 1070 qdict_put(dict, "error", qstring_from_str(strerror(-ret))); 1071 } 1072 1073 if (block_job_is_cancelled(bs->job)) { 1074 monitor_protocol_event(QEVENT_BLOCK_JOB_CANCELLED, obj); 1075 } else { 1076 monitor_protocol_event(QEVENT_BLOCK_JOB_COMPLETED, obj); 1077 } 1078 qobject_decref(obj); 1079 1080 drive_put_ref_bh_schedule(drive_get_by_blockdev(bs)); 1081 } 1082 1083 void qmp_block_stream(const char *device, bool has_base, 1084 const char *base, bool has_speed, int64_t speed, 1085 bool has_on_error, BlockdevOnError on_error, 1086 Error **errp) 1087 { 1088 BlockDriverState *bs; 1089 BlockDriverState *base_bs = NULL; 1090 Error *local_err = NULL; 1091 1092 if (!has_on_error) { 1093 on_error = BLOCKDEV_ON_ERROR_REPORT; 1094 } 1095 1096 bs = bdrv_find(device); 1097 if (!bs) { 1098 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 1099 return; 1100 } 1101 1102 if (base) { 1103 base_bs = bdrv_find_backing_image(bs, base); 1104 if (base_bs == NULL) { 1105 error_set(errp, QERR_BASE_NOT_FOUND, base); 1106 return; 1107 } 1108 } 1109 1110 stream_start(bs, base_bs, base, has_speed ? speed : 0, 1111 on_error, block_job_cb, bs, &local_err); 1112 if (error_is_set(&local_err)) { 1113 error_propagate(errp, local_err); 1114 return; 1115 } 1116 1117 /* Grab a reference so hotplug does not delete the BlockDriverState from 1118 * underneath us. 1119 */ 1120 drive_get_ref(drive_get_by_blockdev(bs)); 1121 1122 trace_qmp_block_stream(bs, bs->job); 1123 } 1124 1125 void qmp_block_commit(const char *device, 1126 bool has_base, const char *base, const char *top, 1127 bool has_speed, int64_t speed, 1128 Error **errp) 1129 { 1130 BlockDriverState *bs; 1131 BlockDriverState *base_bs, *top_bs; 1132 Error *local_err = NULL; 1133 /* This will be part of the QMP command, if/when the 1134 * BlockdevOnError change for blkmirror makes it in 1135 */ 1136 BlockdevOnError on_error = BLOCKDEV_ON_ERROR_REPORT; 1137 1138 /* drain all i/o before commits */ 1139 bdrv_drain_all(); 1140 1141 bs = bdrv_find(device); 1142 if (!bs) { 1143 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 1144 return; 1145 } 1146 1147 /* default top_bs is the active layer */ 1148 top_bs = bs; 1149 1150 if (top) { 1151 if (strcmp(bs->filename, top) != 0) { 1152 top_bs = bdrv_find_backing_image(bs, top); 1153 } 1154 } 1155 1156 if (top_bs == NULL) { 1157 error_setg(errp, "Top image file %s not found", top ? top : "NULL"); 1158 return; 1159 } 1160 1161 if (has_base && base) { 1162 base_bs = bdrv_find_backing_image(top_bs, base); 1163 } else { 1164 base_bs = bdrv_find_base(top_bs); 1165 } 1166 1167 if (base_bs == NULL) { 1168 error_set(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL"); 1169 return; 1170 } 1171 1172 commit_start(bs, base_bs, top_bs, speed, on_error, block_job_cb, bs, 1173 &local_err); 1174 if (local_err != NULL) { 1175 error_propagate(errp, local_err); 1176 return; 1177 } 1178 /* Grab a reference so hotplug does not delete the BlockDriverState from 1179 * underneath us. 1180 */ 1181 drive_get_ref(drive_get_by_blockdev(bs)); 1182 } 1183 1184 void qmp_drive_mirror(const char *device, const char *target, 1185 bool has_format, const char *format, 1186 enum MirrorSyncMode sync, 1187 bool has_mode, enum NewImageMode mode, 1188 bool has_speed, int64_t speed, 1189 bool has_on_source_error, BlockdevOnError on_source_error, 1190 bool has_on_target_error, BlockdevOnError on_target_error, 1191 Error **errp) 1192 { 1193 BlockDriverInfo bdi; 1194 BlockDriverState *bs; 1195 BlockDriverState *source, *target_bs; 1196 BlockDriver *proto_drv; 1197 BlockDriver *drv = NULL; 1198 Error *local_err = NULL; 1199 int flags; 1200 uint64_t size; 1201 int ret; 1202 1203 if (!has_speed) { 1204 speed = 0; 1205 } 1206 if (!has_on_source_error) { 1207 on_source_error = BLOCKDEV_ON_ERROR_REPORT; 1208 } 1209 if (!has_on_target_error) { 1210 on_target_error = BLOCKDEV_ON_ERROR_REPORT; 1211 } 1212 if (!has_mode) { 1213 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS; 1214 } 1215 1216 bs = bdrv_find(device); 1217 if (!bs) { 1218 error_set(errp, QERR_DEVICE_NOT_FOUND, device); 1219 return; 1220 } 1221 1222 if (!bdrv_is_inserted(bs)) { 1223 error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device); 1224 return; 1225 } 1226 1227 if (!has_format) { 1228 format = mode == NEW_IMAGE_MODE_EXISTING ? NULL : bs->drv->format_name; 1229 } 1230 if (format) { 1231 drv = bdrv_find_format(format); 1232 if (!drv) { 1233 error_set(errp, QERR_INVALID_BLOCK_FORMAT, format); 1234 return; 1235 } 1236 } 1237 1238 if (bdrv_in_use(bs)) { 1239 error_set(errp, QERR_DEVICE_IN_USE, device); 1240 return; 1241 } 1242 1243 flags = bs->open_flags | BDRV_O_RDWR; 1244 source = bs->backing_hd; 1245 if (!source && sync == MIRROR_SYNC_MODE_TOP) { 1246 sync = MIRROR_SYNC_MODE_FULL; 1247 } 1248 1249 proto_drv = bdrv_find_protocol(target); 1250 if (!proto_drv) { 1251 error_set(errp, QERR_INVALID_BLOCK_FORMAT, format); 1252 return; 1253 } 1254 1255 if (sync == MIRROR_SYNC_MODE_FULL && mode != NEW_IMAGE_MODE_EXISTING) { 1256 /* create new image w/o backing file */ 1257 assert(format && drv); 1258 bdrv_get_geometry(bs, &size); 1259 size *= 512; 1260 ret = bdrv_img_create(target, format, 1261 NULL, NULL, NULL, size, flags); 1262 } else { 1263 switch (mode) { 1264 case NEW_IMAGE_MODE_EXISTING: 1265 ret = 0; 1266 break; 1267 case NEW_IMAGE_MODE_ABSOLUTE_PATHS: 1268 /* create new image with backing file */ 1269 ret = bdrv_img_create(target, format, 1270 source->filename, 1271 source->drv->format_name, 1272 NULL, -1, flags); 1273 break; 1274 default: 1275 abort(); 1276 } 1277 } 1278 1279 if (ret) { 1280 error_set(errp, QERR_OPEN_FILE_FAILED, target); 1281 return; 1282 } 1283 1284 target_bs = bdrv_new(""); 1285 ret = bdrv_open(target_bs, target, flags | BDRV_O_NO_BACKING, drv); 1286 1287 if (ret < 0) { 1288 bdrv_delete(target_bs); 1289 error_set(errp, QERR_OPEN_FILE_FAILED, target); 1290 return; 1291 } 1292 1293 /* We need a backing file if we will copy parts of a cluster. */ 1294 if (bdrv_get_info(target_bs, &bdi) >= 0 && bdi.cluster_size != 0 && 1295 bdi.cluster_size >= BDRV_SECTORS_PER_DIRTY_CHUNK * 512) { 1296 ret = bdrv_open_backing_file(target_bs); 1297 if (ret < 0) { 1298 bdrv_delete(target_bs); 1299 error_set(errp, QERR_OPEN_FILE_FAILED, target); 1300 return; 1301 } 1302 } 1303 1304 mirror_start(bs, target_bs, speed, sync, on_source_error, on_target_error, 1305 block_job_cb, bs, &local_err); 1306 if (local_err != NULL) { 1307 bdrv_delete(target_bs); 1308 error_propagate(errp, local_err); 1309 return; 1310 } 1311 1312 /* Grab a reference so hotplug does not delete the BlockDriverState from 1313 * underneath us. 1314 */ 1315 drive_get_ref(drive_get_by_blockdev(bs)); 1316 } 1317 1318 static BlockJob *find_block_job(const char *device) 1319 { 1320 BlockDriverState *bs; 1321 1322 bs = bdrv_find(device); 1323 if (!bs || !bs->job) { 1324 return NULL; 1325 } 1326 return bs->job; 1327 } 1328 1329 void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp) 1330 { 1331 BlockJob *job = find_block_job(device); 1332 1333 if (!job) { 1334 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device); 1335 return; 1336 } 1337 1338 block_job_set_speed(job, speed, errp); 1339 } 1340 1341 void qmp_block_job_cancel(const char *device, 1342 bool has_force, bool force, Error **errp) 1343 { 1344 BlockJob *job = find_block_job(device); 1345 1346 if (!has_force) { 1347 force = false; 1348 } 1349 1350 if (!job) { 1351 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device); 1352 return; 1353 } 1354 if (job->paused && !force) { 1355 error_set(errp, QERR_BLOCK_JOB_PAUSED, device); 1356 return; 1357 } 1358 1359 trace_qmp_block_job_cancel(job); 1360 block_job_cancel(job); 1361 } 1362 1363 void qmp_block_job_pause(const char *device, Error **errp) 1364 { 1365 BlockJob *job = find_block_job(device); 1366 1367 if (!job) { 1368 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device); 1369 return; 1370 } 1371 1372 trace_qmp_block_job_pause(job); 1373 block_job_pause(job); 1374 } 1375 1376 void qmp_block_job_resume(const char *device, Error **errp) 1377 { 1378 BlockJob *job = find_block_job(device); 1379 1380 if (!job) { 1381 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device); 1382 return; 1383 } 1384 1385 trace_qmp_block_job_resume(job); 1386 block_job_resume(job); 1387 } 1388 1389 void qmp_block_job_complete(const char *device, Error **errp) 1390 { 1391 BlockJob *job = find_block_job(device); 1392 1393 if (!job) { 1394 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device); 1395 return; 1396 } 1397 1398 trace_qmp_block_job_complete(job); 1399 block_job_complete(job, errp); 1400 } 1401 1402 static void do_qmp_query_block_jobs_one(void *opaque, BlockDriverState *bs) 1403 { 1404 BlockJobInfoList **prev = opaque; 1405 BlockJob *job = bs->job; 1406 1407 if (job) { 1408 BlockJobInfoList *elem = g_new0(BlockJobInfoList, 1); 1409 elem->value = block_job_query(bs->job); 1410 (*prev)->next = elem; 1411 *prev = elem; 1412 } 1413 } 1414 1415 BlockJobInfoList *qmp_query_block_jobs(Error **errp) 1416 { 1417 /* Dummy is a fake list element for holding the head pointer */ 1418 BlockJobInfoList dummy = {}; 1419 BlockJobInfoList *prev = &dummy; 1420 bdrv_iterate(do_qmp_query_block_jobs_one, &prev); 1421 return dummy.next; 1422 } 1423