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 "block.h" 11 #include "blockdev.h" 12 #include "monitor.h" 13 #include "qerror.h" 14 #include "qemu-option.h" 15 #include "qemu-config.h" 16 #include "sysemu.h" 17 #include "hw/qdev.h" 18 #include "block_int.h" 19 20 static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives); 21 22 /* 23 * We automatically delete the drive when a device using it gets 24 * unplugged. Questionable feature, but we can't just drop it. 25 * Device models call blockdev_mark_auto_del() to schedule the 26 * automatic deletion, and generic qdev code calls blockdev_auto_del() 27 * when deletion is actually safe. 28 */ 29 void blockdev_mark_auto_del(BlockDriverState *bs) 30 { 31 DriveInfo *dinfo = drive_get_by_blockdev(bs); 32 33 if (dinfo) { 34 dinfo->auto_del = 1; 35 } 36 } 37 38 void blockdev_auto_del(BlockDriverState *bs) 39 { 40 DriveInfo *dinfo = drive_get_by_blockdev(bs); 41 42 if (dinfo && dinfo->auto_del) { 43 drive_uninit(dinfo); 44 } 45 } 46 47 QemuOpts *drive_add(const char *file, const char *fmt, ...) 48 { 49 va_list ap; 50 char optstr[1024]; 51 QemuOpts *opts; 52 53 va_start(ap, fmt); 54 vsnprintf(optstr, sizeof(optstr), fmt, ap); 55 va_end(ap); 56 57 opts = qemu_opts_parse(qemu_find_opts("drive"), optstr, 0); 58 if (!opts) { 59 return NULL; 60 } 61 if (file) 62 qemu_opt_set(opts, "file", file); 63 return opts; 64 } 65 66 DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit) 67 { 68 DriveInfo *dinfo; 69 70 /* seek interface, bus and unit */ 71 72 QTAILQ_FOREACH(dinfo, &drives, next) { 73 if (dinfo->type == type && 74 dinfo->bus == bus && 75 dinfo->unit == unit) 76 return dinfo; 77 } 78 79 return NULL; 80 } 81 82 int drive_get_max_bus(BlockInterfaceType type) 83 { 84 int max_bus; 85 DriveInfo *dinfo; 86 87 max_bus = -1; 88 QTAILQ_FOREACH(dinfo, &drives, next) { 89 if(dinfo->type == type && 90 dinfo->bus > max_bus) 91 max_bus = dinfo->bus; 92 } 93 return max_bus; 94 } 95 96 DriveInfo *drive_get_by_blockdev(BlockDriverState *bs) 97 { 98 DriveInfo *dinfo; 99 100 QTAILQ_FOREACH(dinfo, &drives, next) { 101 if (dinfo->bdrv == bs) { 102 return dinfo; 103 } 104 } 105 return NULL; 106 } 107 108 static void bdrv_format_print(void *opaque, const char *name) 109 { 110 fprintf(stderr, " %s", name); 111 } 112 113 void drive_uninit(DriveInfo *dinfo) 114 { 115 qemu_opts_del(dinfo->opts); 116 bdrv_delete(dinfo->bdrv); 117 QTAILQ_REMOVE(&drives, dinfo, next); 118 qemu_free(dinfo); 119 } 120 121 static int parse_block_error_action(const char *buf, int is_read) 122 { 123 if (!strcmp(buf, "ignore")) { 124 return BLOCK_ERR_IGNORE; 125 } else if (!is_read && !strcmp(buf, "enospc")) { 126 return BLOCK_ERR_STOP_ENOSPC; 127 } else if (!strcmp(buf, "stop")) { 128 return BLOCK_ERR_STOP_ANY; 129 } else if (!strcmp(buf, "report")) { 130 return BLOCK_ERR_REPORT; 131 } else { 132 fprintf(stderr, "qemu: '%s' invalid %s error action\n", 133 buf, is_read ? "read" : "write"); 134 return -1; 135 } 136 } 137 138 DriveInfo *drive_init(QemuOpts *opts, int default_to_scsi, int *fatal_error) 139 { 140 const char *buf; 141 const char *file = NULL; 142 char devname[128]; 143 const char *serial; 144 const char *mediastr = ""; 145 BlockInterfaceType type; 146 enum { MEDIA_DISK, MEDIA_CDROM } media; 147 int bus_id, unit_id; 148 int cyls, heads, secs, translation; 149 BlockDriver *drv = NULL; 150 int max_devs; 151 int index; 152 int ro = 0; 153 int bdrv_flags = 0; 154 int on_read_error, on_write_error; 155 const char *devaddr; 156 DriveInfo *dinfo; 157 int snapshot = 0; 158 int ret; 159 160 *fatal_error = 1; 161 162 translation = BIOS_ATA_TRANSLATION_AUTO; 163 164 if (default_to_scsi) { 165 type = IF_SCSI; 166 max_devs = MAX_SCSI_DEVS; 167 pstrcpy(devname, sizeof(devname), "scsi"); 168 } else { 169 type = IF_IDE; 170 max_devs = MAX_IDE_DEVS; 171 pstrcpy(devname, sizeof(devname), "ide"); 172 } 173 media = MEDIA_DISK; 174 175 /* extract parameters */ 176 bus_id = qemu_opt_get_number(opts, "bus", 0); 177 unit_id = qemu_opt_get_number(opts, "unit", -1); 178 index = qemu_opt_get_number(opts, "index", -1); 179 180 cyls = qemu_opt_get_number(opts, "cyls", 0); 181 heads = qemu_opt_get_number(opts, "heads", 0); 182 secs = qemu_opt_get_number(opts, "secs", 0); 183 184 snapshot = qemu_opt_get_bool(opts, "snapshot", 0); 185 ro = qemu_opt_get_bool(opts, "readonly", 0); 186 187 file = qemu_opt_get(opts, "file"); 188 serial = qemu_opt_get(opts, "serial"); 189 190 if ((buf = qemu_opt_get(opts, "if")) != NULL) { 191 pstrcpy(devname, sizeof(devname), buf); 192 if (!strcmp(buf, "ide")) { 193 type = IF_IDE; 194 max_devs = MAX_IDE_DEVS; 195 } else if (!strcmp(buf, "scsi")) { 196 type = IF_SCSI; 197 max_devs = MAX_SCSI_DEVS; 198 } else if (!strcmp(buf, "floppy")) { 199 type = IF_FLOPPY; 200 max_devs = 0; 201 } else if (!strcmp(buf, "pflash")) { 202 type = IF_PFLASH; 203 max_devs = 0; 204 } else if (!strcmp(buf, "mtd")) { 205 type = IF_MTD; 206 max_devs = 0; 207 } else if (!strcmp(buf, "sd")) { 208 type = IF_SD; 209 max_devs = 0; 210 } else if (!strcmp(buf, "virtio")) { 211 type = IF_VIRTIO; 212 max_devs = 0; 213 } else if (!strcmp(buf, "xen")) { 214 type = IF_XEN; 215 max_devs = 0; 216 } else if (!strcmp(buf, "none")) { 217 type = IF_NONE; 218 max_devs = 0; 219 } else { 220 fprintf(stderr, "qemu: unsupported bus type '%s'\n", buf); 221 return NULL; 222 } 223 } 224 225 if (cyls || heads || secs) { 226 if (cyls < 1 || (type == IF_IDE && cyls > 16383)) { 227 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf); 228 return NULL; 229 } 230 if (heads < 1 || (type == IF_IDE && heads > 16)) { 231 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf); 232 return NULL; 233 } 234 if (secs < 1 || (type == IF_IDE && secs > 63)) { 235 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf); 236 return NULL; 237 } 238 } 239 240 if ((buf = qemu_opt_get(opts, "trans")) != NULL) { 241 if (!cyls) { 242 fprintf(stderr, 243 "qemu: '%s' trans must be used with cyls,heads and secs\n", 244 buf); 245 return NULL; 246 } 247 if (!strcmp(buf, "none")) 248 translation = BIOS_ATA_TRANSLATION_NONE; 249 else if (!strcmp(buf, "lba")) 250 translation = BIOS_ATA_TRANSLATION_LBA; 251 else if (!strcmp(buf, "auto")) 252 translation = BIOS_ATA_TRANSLATION_AUTO; 253 else { 254 fprintf(stderr, "qemu: '%s' invalid translation type\n", buf); 255 return NULL; 256 } 257 } 258 259 if ((buf = qemu_opt_get(opts, "media")) != NULL) { 260 if (!strcmp(buf, "disk")) { 261 media = MEDIA_DISK; 262 } else if (!strcmp(buf, "cdrom")) { 263 if (cyls || secs || heads) { 264 fprintf(stderr, 265 "qemu: '%s' invalid physical CHS format\n", buf); 266 return NULL; 267 } 268 media = MEDIA_CDROM; 269 } else { 270 fprintf(stderr, "qemu: '%s' invalid media\n", buf); 271 return NULL; 272 } 273 } 274 275 if ((buf = qemu_opt_get(opts, "cache")) != NULL) { 276 if (!strcmp(buf, "off") || !strcmp(buf, "none")) { 277 bdrv_flags |= BDRV_O_NOCACHE; 278 } else if (!strcmp(buf, "writeback")) { 279 bdrv_flags |= BDRV_O_CACHE_WB; 280 } else if (!strcmp(buf, "unsafe")) { 281 bdrv_flags |= BDRV_O_CACHE_WB; 282 bdrv_flags |= BDRV_O_NO_FLUSH; 283 } else if (!strcmp(buf, "writethrough")) { 284 /* this is the default */ 285 } else { 286 fprintf(stderr, "qemu: invalid cache option\n"); 287 return NULL; 288 } 289 } 290 291 #ifdef CONFIG_LINUX_AIO 292 if ((buf = qemu_opt_get(opts, "aio")) != NULL) { 293 if (!strcmp(buf, "native")) { 294 bdrv_flags |= BDRV_O_NATIVE_AIO; 295 } else if (!strcmp(buf, "threads")) { 296 /* this is the default */ 297 } else { 298 fprintf(stderr, "qemu: invalid aio option\n"); 299 return NULL; 300 } 301 } 302 #endif 303 304 if ((buf = qemu_opt_get(opts, "format")) != NULL) { 305 if (strcmp(buf, "?") == 0) { 306 fprintf(stderr, "qemu: Supported formats:"); 307 bdrv_iterate_format(bdrv_format_print, NULL); 308 fprintf(stderr, "\n"); 309 return NULL; 310 } 311 drv = bdrv_find_whitelisted_format(buf); 312 if (!drv) { 313 fprintf(stderr, "qemu: '%s' invalid format\n", buf); 314 return NULL; 315 } 316 } 317 318 on_write_error = BLOCK_ERR_STOP_ENOSPC; 319 if ((buf = qemu_opt_get(opts, "werror")) != NULL) { 320 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && type != IF_NONE) { 321 fprintf(stderr, "werror is not supported by this format\n"); 322 return NULL; 323 } 324 325 on_write_error = parse_block_error_action(buf, 0); 326 if (on_write_error < 0) { 327 return NULL; 328 } 329 } 330 331 on_read_error = BLOCK_ERR_REPORT; 332 if ((buf = qemu_opt_get(opts, "rerror")) != NULL) { 333 if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI && type != IF_NONE) { 334 fprintf(stderr, "rerror is not supported by this format\n"); 335 return NULL; 336 } 337 338 on_read_error = parse_block_error_action(buf, 1); 339 if (on_read_error < 0) { 340 return NULL; 341 } 342 } 343 344 if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) { 345 if (type != IF_VIRTIO) { 346 fprintf(stderr, "addr is not supported\n"); 347 return NULL; 348 } 349 } 350 351 /* compute bus and unit according index */ 352 353 if (index != -1) { 354 if (bus_id != 0 || unit_id != -1) { 355 fprintf(stderr, 356 "qemu: index cannot be used with bus and unit\n"); 357 return NULL; 358 } 359 if (max_devs == 0) 360 { 361 unit_id = index; 362 bus_id = 0; 363 } else { 364 unit_id = index % max_devs; 365 bus_id = index / max_devs; 366 } 367 } 368 369 /* if user doesn't specify a unit_id, 370 * try to find the first free 371 */ 372 373 if (unit_id == -1) { 374 unit_id = 0; 375 while (drive_get(type, bus_id, unit_id) != NULL) { 376 unit_id++; 377 if (max_devs && unit_id >= max_devs) { 378 unit_id -= max_devs; 379 bus_id++; 380 } 381 } 382 } 383 384 /* check unit id */ 385 386 if (max_devs && unit_id >= max_devs) { 387 fprintf(stderr, "qemu: unit %d too big (max is %d)\n", 388 unit_id, max_devs - 1); 389 return NULL; 390 } 391 392 /* 393 * ignore multiple definitions 394 */ 395 396 if (drive_get(type, bus_id, unit_id) != NULL) { 397 *fatal_error = 0; 398 return NULL; 399 } 400 401 /* init */ 402 403 dinfo = qemu_mallocz(sizeof(*dinfo)); 404 if ((buf = qemu_opts_id(opts)) != NULL) { 405 dinfo->id = qemu_strdup(buf); 406 } else { 407 /* no id supplied -> create one */ 408 dinfo->id = qemu_mallocz(32); 409 if (type == IF_IDE || type == IF_SCSI) 410 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd"; 411 if (max_devs) 412 snprintf(dinfo->id, 32, "%s%i%s%i", 413 devname, bus_id, mediastr, unit_id); 414 else 415 snprintf(dinfo->id, 32, "%s%s%i", 416 devname, mediastr, unit_id); 417 } 418 dinfo->bdrv = bdrv_new(dinfo->id); 419 dinfo->devaddr = devaddr; 420 dinfo->type = type; 421 dinfo->bus = bus_id; 422 dinfo->unit = unit_id; 423 dinfo->opts = opts; 424 if (serial) 425 strncpy(dinfo->serial, serial, sizeof(dinfo->serial) - 1); 426 QTAILQ_INSERT_TAIL(&drives, dinfo, next); 427 428 bdrv_set_on_error(dinfo->bdrv, on_read_error, on_write_error); 429 430 switch(type) { 431 case IF_IDE: 432 case IF_SCSI: 433 case IF_XEN: 434 case IF_NONE: 435 switch(media) { 436 case MEDIA_DISK: 437 if (cyls != 0) { 438 bdrv_set_geometry_hint(dinfo->bdrv, cyls, heads, secs); 439 bdrv_set_translation_hint(dinfo->bdrv, translation); 440 } 441 break; 442 case MEDIA_CDROM: 443 bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_CDROM); 444 break; 445 } 446 break; 447 case IF_SD: 448 /* FIXME: This isn't really a floppy, but it's a reasonable 449 approximation. */ 450 case IF_FLOPPY: 451 bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_FLOPPY); 452 break; 453 case IF_PFLASH: 454 case IF_MTD: 455 break; 456 case IF_VIRTIO: 457 /* add virtio block device */ 458 opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0); 459 qemu_opt_set(opts, "driver", "virtio-blk-pci"); 460 qemu_opt_set(opts, "drive", dinfo->id); 461 if (devaddr) 462 qemu_opt_set(opts, "addr", devaddr); 463 break; 464 case IF_COUNT: 465 abort(); 466 } 467 if (!file || !*file) { 468 *fatal_error = 0; 469 return NULL; 470 } 471 if (snapshot) { 472 /* always use cache=unsafe with snapshot */ 473 bdrv_flags &= ~BDRV_O_CACHE_MASK; 474 bdrv_flags |= (BDRV_O_SNAPSHOT|BDRV_O_CACHE_WB|BDRV_O_NO_FLUSH); 475 } 476 477 if (media == MEDIA_CDROM) { 478 /* CDROM is fine for any interface, don't check. */ 479 ro = 1; 480 } else if (ro == 1) { 481 if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY && type != IF_NONE) { 482 fprintf(stderr, "qemu: readonly flag not supported for drive with this interface\n"); 483 return NULL; 484 } 485 } 486 487 bdrv_flags |= ro ? 0 : BDRV_O_RDWR; 488 489 ret = bdrv_open(dinfo->bdrv, file, bdrv_flags, drv); 490 if (ret < 0) { 491 fprintf(stderr, "qemu: could not open disk image %s: %s\n", 492 file, strerror(-ret)); 493 return NULL; 494 } 495 496 if (bdrv_key_required(dinfo->bdrv)) 497 autostart = 0; 498 *fatal_error = 0; 499 return dinfo; 500 } 501 502 void do_commit(Monitor *mon, const QDict *qdict) 503 { 504 const char *device = qdict_get_str(qdict, "device"); 505 BlockDriverState *bs; 506 507 if (!strcmp(device, "all")) { 508 bdrv_commit_all(); 509 } else { 510 bs = bdrv_find(device); 511 if (!bs) { 512 qerror_report(QERR_DEVICE_NOT_FOUND, device); 513 return; 514 } 515 bdrv_commit(bs); 516 } 517 } 518 519 int do_snapshot_blkdev(Monitor *mon, const QDict *qdict, QObject **ret_data) 520 { 521 const char *device = qdict_get_str(qdict, "device"); 522 const char *filename = qdict_get_try_str(qdict, "snapshot_file"); 523 const char *format = qdict_get_try_str(qdict, "format"); 524 BlockDriverState *bs; 525 BlockDriver *drv, *proto_drv; 526 int ret = 0; 527 int flags; 528 529 bs = bdrv_find(device); 530 if (!bs) { 531 qerror_report(QERR_DEVICE_NOT_FOUND, device); 532 ret = -1; 533 goto out; 534 } 535 536 if (!format) { 537 format = "qcow2"; 538 } 539 540 drv = bdrv_find_format(format); 541 if (!drv) { 542 qerror_report(QERR_INVALID_BLOCK_FORMAT, format); 543 ret = -1; 544 goto out; 545 } 546 547 proto_drv = bdrv_find_protocol(filename); 548 if (!proto_drv) { 549 qerror_report(QERR_INVALID_BLOCK_FORMAT, format); 550 ret = -1; 551 goto out; 552 } 553 554 ret = bdrv_img_create(filename, format, bs->filename, 555 bs->drv->format_name, NULL, -1, bs->open_flags); 556 if (ret) { 557 goto out; 558 } 559 560 qemu_aio_flush(); 561 bdrv_flush(bs); 562 563 flags = bs->open_flags; 564 bdrv_close(bs); 565 ret = bdrv_open(bs, filename, flags, drv); 566 /* 567 * If reopening the image file we just created fails, we really 568 * are in trouble :( 569 */ 570 if (ret != 0) { 571 abort(); 572 } 573 out: 574 if (ret) { 575 ret = -1; 576 } 577 578 return ret; 579 } 580 581 static int eject_device(Monitor *mon, BlockDriverState *bs, int force) 582 { 583 if (!force) { 584 if (!bdrv_is_removable(bs)) { 585 qerror_report(QERR_DEVICE_NOT_REMOVABLE, 586 bdrv_get_device_name(bs)); 587 return -1; 588 } 589 if (bdrv_is_locked(bs)) { 590 qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs)); 591 return -1; 592 } 593 } 594 bdrv_close(bs); 595 return 0; 596 } 597 598 int do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data) 599 { 600 BlockDriverState *bs; 601 int force = qdict_get_try_bool(qdict, "force", 0); 602 const char *filename = qdict_get_str(qdict, "device"); 603 604 bs = bdrv_find(filename); 605 if (!bs) { 606 qerror_report(QERR_DEVICE_NOT_FOUND, filename); 607 return -1; 608 } 609 return eject_device(mon, bs, force); 610 } 611 612 int do_block_set_passwd(Monitor *mon, const QDict *qdict, 613 QObject **ret_data) 614 { 615 BlockDriverState *bs; 616 int err; 617 618 bs = bdrv_find(qdict_get_str(qdict, "device")); 619 if (!bs) { 620 qerror_report(QERR_DEVICE_NOT_FOUND, qdict_get_str(qdict, "device")); 621 return -1; 622 } 623 624 err = bdrv_set_key(bs, qdict_get_str(qdict, "password")); 625 if (err == -EINVAL) { 626 qerror_report(QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs)); 627 return -1; 628 } else if (err < 0) { 629 qerror_report(QERR_INVALID_PASSWORD); 630 return -1; 631 } 632 633 return 0; 634 } 635 636 int do_change_block(Monitor *mon, const char *device, 637 const char *filename, const char *fmt) 638 { 639 BlockDriverState *bs; 640 BlockDriver *drv = NULL; 641 int bdrv_flags; 642 643 bs = bdrv_find(device); 644 if (!bs) { 645 qerror_report(QERR_DEVICE_NOT_FOUND, device); 646 return -1; 647 } 648 if (fmt) { 649 drv = bdrv_find_whitelisted_format(fmt); 650 if (!drv) { 651 qerror_report(QERR_INVALID_BLOCK_FORMAT, fmt); 652 return -1; 653 } 654 } 655 if (eject_device(mon, bs, 0) < 0) { 656 return -1; 657 } 658 bdrv_flags = bdrv_is_read_only(bs) ? 0 : BDRV_O_RDWR; 659 bdrv_flags |= bdrv_is_snapshot(bs) ? BDRV_O_SNAPSHOT : 0; 660 if (bdrv_open(bs, filename, bdrv_flags, drv) < 0) { 661 qerror_report(QERR_OPEN_FILE_FAILED, filename); 662 return -1; 663 } 664 return monitor_read_bdrv_key_start(mon, bs, NULL, NULL); 665 } 666 667 int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data) 668 { 669 const char *id = qdict_get_str(qdict, "id"); 670 BlockDriverState *bs; 671 BlockDriverState **ptr; 672 Property *prop; 673 674 bs = bdrv_find(id); 675 if (!bs) { 676 qerror_report(QERR_DEVICE_NOT_FOUND, id); 677 return -1; 678 } 679 680 /* quiesce block driver; prevent further io */ 681 qemu_aio_flush(); 682 bdrv_flush(bs); 683 bdrv_close(bs); 684 685 /* clean up guest state from pointing to host resource by 686 * finding and removing DeviceState "drive" property */ 687 for (prop = bs->peer->info->props; prop && prop->name; prop++) { 688 if (prop->info->type == PROP_TYPE_DRIVE) { 689 ptr = qdev_get_prop_ptr(bs->peer, prop); 690 if ((*ptr) == bs) { 691 bdrv_detach(bs, bs->peer); 692 *ptr = NULL; 693 break; 694 } 695 } 696 } 697 698 /* clean up host side */ 699 drive_uninit(drive_get_by_blockdev(bs)); 700 701 return 0; 702 } 703