2 * QEMU host block devices
4 * Copyright (c) 2003-2008 Fabrice Bellard
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.
14 #include "qemu-option.h"
15 #include "qemu-config.h"
16 #include "qemu-objects.h"
18 #include "block_int.h"
19 #include "qmp-commands.h"
21 #include "arch_init.h"
23 static QTAILQ_HEAD(drivelist
, DriveInfo
) drives
= QTAILQ_HEAD_INITIALIZER(drives
);
25 static const char *const if_name
[IF_COUNT
] = {
29 [IF_FLOPPY
] = "floppy",
30 [IF_PFLASH
] = "pflash",
33 [IF_VIRTIO
] = "virtio",
37 static const int if_max_devs
[IF_COUNT
] = {
39 * Do not change these numbers! They govern how drive option
40 * index maps to unit and bus. That mapping is ABI.
42 * All controllers used to imlement if=T drives need to support
43 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
44 * Otherwise, some index values map to "impossible" bus, unit
47 * For instance, if you change [IF_SCSI] to 255, -drive
48 * if=scsi,index=12 no longer means bus=1,unit=5, but
49 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
50 * the drive can't be set up. Regression.
57 * We automatically delete the drive when a device using it gets
58 * unplugged. Questionable feature, but we can't just drop it.
59 * Device models call blockdev_mark_auto_del() to schedule the
60 * automatic deletion, and generic qdev code calls blockdev_auto_del()
61 * when deletion is actually safe.
63 void blockdev_mark_auto_del(BlockDriverState
*bs
)
65 DriveInfo
*dinfo
= drive_get_by_blockdev(bs
);
72 void blockdev_auto_del(BlockDriverState
*bs
)
74 DriveInfo
*dinfo
= drive_get_by_blockdev(bs
);
76 if (dinfo
&& dinfo
->auto_del
) {
81 static int drive_index_to_bus_id(BlockInterfaceType type
, int index
)
83 int max_devs
= if_max_devs
[type
];
84 return max_devs
? index
/ max_devs
: 0;
87 static int drive_index_to_unit_id(BlockInterfaceType type
, int index
)
89 int max_devs
= if_max_devs
[type
];
90 return max_devs
? index
% max_devs
: index
;
93 QemuOpts
*drive_def(const char *optstr
)
95 return qemu_opts_parse(qemu_find_opts("drive"), optstr
, 0);
98 QemuOpts
*drive_add(BlockInterfaceType type
, int index
, const char *file
,
104 opts
= drive_def(optstr
);
108 if (type
!= IF_DEFAULT
) {
109 qemu_opt_set(opts
, "if", if_name
[type
]);
112 snprintf(buf
, sizeof(buf
), "%d", index
);
113 qemu_opt_set(opts
, "index", buf
);
116 qemu_opt_set(opts
, "file", file
);
120 DriveInfo
*drive_get(BlockInterfaceType type
, int bus
, int unit
)
124 /* seek interface, bus and unit */
126 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
127 if (dinfo
->type
== type
&&
136 DriveInfo
*drive_get_by_index(BlockInterfaceType type
, int index
)
138 return drive_get(type
,
139 drive_index_to_bus_id(type
, index
),
140 drive_index_to_unit_id(type
, index
));
143 int drive_get_max_bus(BlockInterfaceType type
)
149 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
150 if(dinfo
->type
== type
&&
151 dinfo
->bus
> max_bus
)
152 max_bus
= dinfo
->bus
;
157 /* Get a block device. This should only be used for single-drive devices
158 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
160 DriveInfo
*drive_get_next(BlockInterfaceType type
)
162 static int next_block_unit
[IF_COUNT
];
164 return drive_get(type
, 0, next_block_unit
[type
]++);
167 DriveInfo
*drive_get_by_blockdev(BlockDriverState
*bs
)
171 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
172 if (dinfo
->bdrv
== bs
) {
179 static void bdrv_format_print(void *opaque
, const char *name
)
181 error_printf(" %s", name
);
184 static void drive_uninit(DriveInfo
*dinfo
)
186 qemu_opts_del(dinfo
->opts
);
187 bdrv_delete(dinfo
->bdrv
);
189 QTAILQ_REMOVE(&drives
, dinfo
, next
);
193 void drive_put_ref(DriveInfo
*dinfo
)
195 assert(dinfo
->refcount
);
196 if (--dinfo
->refcount
== 0) {
201 void drive_get_ref(DriveInfo
*dinfo
)
211 static void drive_put_ref_bh(void *opaque
)
213 DrivePutRefBH
*s
= opaque
;
215 drive_put_ref(s
->dinfo
);
216 qemu_bh_delete(s
->bh
);
221 * Release a drive reference in a BH
223 * It is not possible to use drive_put_ref() from a callback function when the
224 * callers still need the drive. In such cases we schedule a BH to release the
227 static void drive_put_ref_bh_schedule(DriveInfo
*dinfo
)
231 s
= g_new(DrivePutRefBH
, 1);
232 s
->bh
= qemu_bh_new(drive_put_ref_bh
, s
);
234 qemu_bh_schedule(s
->bh
);
237 static int parse_block_error_action(const char *buf
, int is_read
)
239 if (!strcmp(buf
, "ignore")) {
240 return BLOCK_ERR_IGNORE
;
241 } else if (!is_read
&& !strcmp(buf
, "enospc")) {
242 return BLOCK_ERR_STOP_ENOSPC
;
243 } else if (!strcmp(buf
, "stop")) {
244 return BLOCK_ERR_STOP_ANY
;
245 } else if (!strcmp(buf
, "report")) {
246 return BLOCK_ERR_REPORT
;
248 error_report("'%s' invalid %s error action",
249 buf
, is_read
? "read" : "write");
254 static bool do_check_io_limits(BlockIOLimit
*io_limits
)
261 bps_flag
= (io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
] != 0)
262 && ((io_limits
->bps
[BLOCK_IO_LIMIT_READ
] != 0)
263 || (io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
] != 0));
264 iops_flag
= (io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
] != 0)
265 && ((io_limits
->iops
[BLOCK_IO_LIMIT_READ
] != 0)
266 || (io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
] != 0));
267 if (bps_flag
|| iops_flag
) {
274 DriveInfo
*drive_init(QemuOpts
*opts
, int default_to_scsi
)
277 const char *file
= NULL
;
280 const char *mediastr
= "";
281 BlockInterfaceType type
;
282 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
284 int cyls
, heads
, secs
, translation
;
285 BlockDriver
*drv
= NULL
;
290 int on_read_error
, on_write_error
;
293 BlockIOLimit io_limits
;
298 translation
= BIOS_ATA_TRANSLATION_AUTO
;
301 /* extract parameters */
302 bus_id
= qemu_opt_get_number(opts
, "bus", 0);
303 unit_id
= qemu_opt_get_number(opts
, "unit", -1);
304 index
= qemu_opt_get_number(opts
, "index", -1);
306 cyls
= qemu_opt_get_number(opts
, "cyls", 0);
307 heads
= qemu_opt_get_number(opts
, "heads", 0);
308 secs
= qemu_opt_get_number(opts
, "secs", 0);
310 snapshot
= qemu_opt_get_bool(opts
, "snapshot", 0);
311 ro
= qemu_opt_get_bool(opts
, "readonly", 0);
312 copy_on_read
= qemu_opt_get_bool(opts
, "copy-on-read", false);
314 file
= qemu_opt_get(opts
, "file");
315 serial
= qemu_opt_get(opts
, "serial");
317 if ((buf
= qemu_opt_get(opts
, "if")) != NULL
) {
318 pstrcpy(devname
, sizeof(devname
), buf
);
319 for (type
= 0; type
< IF_COUNT
&& strcmp(buf
, if_name
[type
]); type
++)
321 if (type
== IF_COUNT
) {
322 error_report("unsupported bus type '%s'", buf
);
326 type
= default_to_scsi
? IF_SCSI
: IF_IDE
;
327 pstrcpy(devname
, sizeof(devname
), if_name
[type
]);
330 max_devs
= if_max_devs
[type
];
332 if (cyls
|| heads
|| secs
) {
333 if (cyls
< 1 || (type
== IF_IDE
&& cyls
> 16383)) {
334 error_report("invalid physical cyls number");
337 if (heads
< 1 || (type
== IF_IDE
&& heads
> 16)) {
338 error_report("invalid physical heads number");
341 if (secs
< 1 || (type
== IF_IDE
&& secs
> 63)) {
342 error_report("invalid physical secs number");
347 if ((buf
= qemu_opt_get(opts
, "trans")) != NULL
) {
349 error_report("'%s' trans must be used with cyls, heads and secs",
353 if (!strcmp(buf
, "none"))
354 translation
= BIOS_ATA_TRANSLATION_NONE
;
355 else if (!strcmp(buf
, "lba"))
356 translation
= BIOS_ATA_TRANSLATION_LBA
;
357 else if (!strcmp(buf
, "auto"))
358 translation
= BIOS_ATA_TRANSLATION_AUTO
;
360 error_report("'%s' invalid translation type", buf
);
365 if ((buf
= qemu_opt_get(opts
, "media")) != NULL
) {
366 if (!strcmp(buf
, "disk")) {
368 } else if (!strcmp(buf
, "cdrom")) {
369 if (cyls
|| secs
|| heads
) {
370 error_report("CHS can't be set with media=%s", buf
);
375 error_report("'%s' invalid media", buf
);
380 if ((buf
= qemu_opt_get(opts
, "cache")) != NULL
) {
381 if (bdrv_parse_cache_flags(buf
, &bdrv_flags
) != 0) {
382 error_report("invalid cache option");
387 #ifdef CONFIG_LINUX_AIO
388 if ((buf
= qemu_opt_get(opts
, "aio")) != NULL
) {
389 if (!strcmp(buf
, "native")) {
390 bdrv_flags
|= BDRV_O_NATIVE_AIO
;
391 } else if (!strcmp(buf
, "threads")) {
392 /* this is the default */
394 error_report("invalid aio option");
400 if ((buf
= qemu_opt_get(opts
, "format")) != NULL
) {
401 if (strcmp(buf
, "?") == 0) {
402 error_printf("Supported formats:");
403 bdrv_iterate_format(bdrv_format_print
, NULL
);
407 drv
= bdrv_find_whitelisted_format(buf
);
409 error_report("'%s' invalid format", buf
);
414 /* disk I/O throttling */
415 io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
] =
416 qemu_opt_get_number(opts
, "bps", 0);
417 io_limits
.bps
[BLOCK_IO_LIMIT_READ
] =
418 qemu_opt_get_number(opts
, "bps_rd", 0);
419 io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
] =
420 qemu_opt_get_number(opts
, "bps_wr", 0);
421 io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
] =
422 qemu_opt_get_number(opts
, "iops", 0);
423 io_limits
.iops
[BLOCK_IO_LIMIT_READ
] =
424 qemu_opt_get_number(opts
, "iops_rd", 0);
425 io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
] =
426 qemu_opt_get_number(opts
, "iops_wr", 0);
428 if (!do_check_io_limits(&io_limits
)) {
429 error_report("bps(iops) and bps_rd/bps_wr(iops_rd/iops_wr) "
430 "cannot be used at the same time");
434 on_write_error
= BLOCK_ERR_STOP_ENOSPC
;
435 if ((buf
= qemu_opt_get(opts
, "werror")) != NULL
) {
436 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
&& type
!= IF_NONE
) {
437 error_report("werror is not supported by this bus type");
441 on_write_error
= parse_block_error_action(buf
, 0);
442 if (on_write_error
< 0) {
447 on_read_error
= BLOCK_ERR_REPORT
;
448 if ((buf
= qemu_opt_get(opts
, "rerror")) != NULL
) {
449 if (type
!= IF_IDE
&& type
!= IF_VIRTIO
&& type
!= IF_SCSI
&& type
!= IF_NONE
) {
450 error_report("rerror is not supported by this bus type");
454 on_read_error
= parse_block_error_action(buf
, 1);
455 if (on_read_error
< 0) {
460 if ((devaddr
= qemu_opt_get(opts
, "addr")) != NULL
) {
461 if (type
!= IF_VIRTIO
) {
462 error_report("addr is not supported by this bus type");
467 /* compute bus and unit according index */
470 if (bus_id
!= 0 || unit_id
!= -1) {
471 error_report("index cannot be used with bus and unit");
474 bus_id
= drive_index_to_bus_id(type
, index
);
475 unit_id
= drive_index_to_unit_id(type
, index
);
478 /* if user doesn't specify a unit_id,
479 * try to find the first free
484 while (drive_get(type
, bus_id
, unit_id
) != NULL
) {
486 if (max_devs
&& unit_id
>= max_devs
) {
495 if (max_devs
&& unit_id
>= max_devs
) {
496 error_report("unit %d too big (max is %d)",
497 unit_id
, max_devs
- 1);
502 * catch multiple definitions
505 if (drive_get(type
, bus_id
, unit_id
) != NULL
) {
506 error_report("drive with bus=%d, unit=%d (index=%d) exists",
507 bus_id
, unit_id
, index
);
513 dinfo
= g_malloc0(sizeof(*dinfo
));
514 if ((buf
= qemu_opts_id(opts
)) != NULL
) {
515 dinfo
->id
= g_strdup(buf
);
517 /* no id supplied -> create one */
518 dinfo
->id
= g_malloc0(32);
519 if (type
== IF_IDE
|| type
== IF_SCSI
)
520 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
522 snprintf(dinfo
->id
, 32, "%s%i%s%i",
523 devname
, bus_id
, mediastr
, unit_id
);
525 snprintf(dinfo
->id
, 32, "%s%s%i",
526 devname
, mediastr
, unit_id
);
528 dinfo
->bdrv
= bdrv_new(dinfo
->id
);
529 dinfo
->devaddr
= devaddr
;
532 dinfo
->unit
= unit_id
;
536 strncpy(dinfo
->serial
, serial
, sizeof(dinfo
->serial
) - 1);
537 QTAILQ_INSERT_TAIL(&drives
, dinfo
, next
);
539 bdrv_set_on_error(dinfo
->bdrv
, on_read_error
, on_write_error
);
541 /* disk I/O throttling */
542 bdrv_set_io_limits(dinfo
->bdrv
, &io_limits
);
552 bdrv_set_geometry_hint(dinfo
->bdrv
, cyls
, heads
, secs
);
553 bdrv_set_translation_hint(dinfo
->bdrv
, translation
);
567 /* add virtio block device */
568 opts
= qemu_opts_create(qemu_find_opts("device"), NULL
, 0);
569 if (arch_type
== QEMU_ARCH_S390X
) {
570 qemu_opt_set(opts
, "driver", "virtio-blk-s390");
572 qemu_opt_set(opts
, "driver", "virtio-blk-pci");
574 qemu_opt_set(opts
, "drive", dinfo
->id
);
576 qemu_opt_set(opts
, "addr", devaddr
);
581 if (!file
|| !*file
) {
585 /* always use cache=unsafe with snapshot */
586 bdrv_flags
&= ~BDRV_O_CACHE_MASK
;
587 bdrv_flags
|= (BDRV_O_SNAPSHOT
|BDRV_O_CACHE_WB
|BDRV_O_NO_FLUSH
);
591 bdrv_flags
|= BDRV_O_COPY_ON_READ
;
594 if (media
== MEDIA_CDROM
) {
595 /* CDROM is fine for any interface, don't check. */
597 } else if (ro
== 1) {
598 if (type
!= IF_SCSI
&& type
!= IF_VIRTIO
&& type
!= IF_FLOPPY
&&
599 type
!= IF_NONE
&& type
!= IF_PFLASH
) {
600 error_report("readonly not supported by this bus type");
605 bdrv_flags
|= ro
? 0 : BDRV_O_RDWR
;
607 ret
= bdrv_open(dinfo
->bdrv
, file
, bdrv_flags
, drv
);
609 error_report("could not open disk image %s: %s",
610 file
, strerror(-ret
));
614 if (bdrv_key_required(dinfo
->bdrv
))
619 bdrv_delete(dinfo
->bdrv
);
621 QTAILQ_REMOVE(&drives
, dinfo
, next
);
626 void do_commit(Monitor
*mon
, const QDict
*qdict
)
628 const char *device
= qdict_get_str(qdict
, "device");
629 BlockDriverState
*bs
;
632 if (!strcmp(device
, "all")) {
633 ret
= bdrv_commit_all();
635 qerror_report(QERR_DEVICE_IN_USE
, device
);
639 bs
= bdrv_find(device
);
641 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
644 ret
= bdrv_commit(bs
);
646 qerror_report(QERR_DEVICE_IN_USE
, device
);
652 void qmp_blockdev_snapshot_sync(const char *device
, const char *snapshot_file
,
653 bool has_format
, const char *format
,
656 BlockDriverState
*bs
;
657 BlockDriver
*drv
, *old_drv
, *proto_drv
;
660 char old_filename
[1024];
662 bs
= bdrv_find(device
);
664 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
667 if (bdrv_in_use(bs
)) {
668 error_set(errp
, QERR_DEVICE_IN_USE
, device
);
672 pstrcpy(old_filename
, sizeof(old_filename
), bs
->filename
);
675 flags
= bs
->open_flags
;
681 drv
= bdrv_find_format(format
);
683 error_set(errp
, QERR_INVALID_BLOCK_FORMAT
, format
);
687 proto_drv
= bdrv_find_protocol(snapshot_file
);
689 error_set(errp
, QERR_INVALID_BLOCK_FORMAT
, format
);
693 ret
= bdrv_img_create(snapshot_file
, format
, bs
->filename
,
694 bs
->drv
->format_name
, NULL
, -1, flags
);
696 error_set(errp
, QERR_UNDEFINED_ERROR
);
704 ret
= bdrv_open(bs
, snapshot_file
, flags
, drv
);
706 * If reopening the image file we just created fails, fall back
707 * and try to re-open the original image. If that fails too, we
708 * are in serious trouble.
711 ret
= bdrv_open(bs
, old_filename
, flags
, old_drv
);
713 error_set(errp
, QERR_OPEN_FILE_FAILED
, old_filename
);
715 error_set(errp
, QERR_OPEN_FILE_FAILED
, snapshot_file
);
721 /* New and old BlockDriverState structs for group snapshots */
722 typedef struct BlkGroupSnapshotStates
{
723 BlockDriverState
*old_bs
;
724 BlockDriverState
*new_bs
;
725 QSIMPLEQ_ENTRY(BlkGroupSnapshotStates
) entry
;
726 } BlkGroupSnapshotStates
;
729 * 'Atomic' group snapshots. The snapshots are taken as a set, and if any fail
730 * then we do not pivot any of the devices in the group, and abandon the
733 void qmp_blockdev_group_snapshot_sync(SnapshotDevList
*dev_list
,
737 SnapshotDevList
*dev_entry
= dev_list
;
738 SnapshotDev
*dev_info
= NULL
;
739 BlkGroupSnapshotStates
*states
;
740 BlockDriver
*proto_drv
;
744 const char *snapshot_file
;
746 QSIMPLEQ_HEAD(snap_bdrv_states
, BlkGroupSnapshotStates
) snap_bdrv_states
;
747 QSIMPLEQ_INIT(&snap_bdrv_states
);
749 /* drain all i/o before any snapshots */
752 /* We don't do anything in this loop that commits us to the snapshot */
753 while (NULL
!= dev_entry
) {
754 dev_info
= dev_entry
->value
;
755 dev_entry
= dev_entry
->next
;
757 states
= g_malloc0(sizeof(BlkGroupSnapshotStates
));
758 QSIMPLEQ_INSERT_TAIL(&snap_bdrv_states
, states
, entry
);
760 states
->old_bs
= bdrv_find(dev_info
->device
);
762 if (!states
->old_bs
) {
763 error_set(errp
, QERR_DEVICE_NOT_FOUND
, dev_info
->device
);
764 goto delete_and_fail
;
767 if (bdrv_in_use(states
->old_bs
)) {
768 error_set(errp
, QERR_DEVICE_IN_USE
, dev_info
->device
);
769 goto delete_and_fail
;
772 if (!bdrv_is_read_only(states
->old_bs
) &&
773 bdrv_is_inserted(states
->old_bs
)) {
775 if (bdrv_flush(states
->old_bs
)) {
776 error_set(errp
, QERR_IO_ERROR
);
777 goto delete_and_fail
;
781 snapshot_file
= dev_info
->snapshot_file
;
783 flags
= states
->old_bs
->open_flags
;
785 if (!dev_info
->has_format
) {
788 format
= dev_info
->format
;
791 drv
= bdrv_find_format(format
);
793 error_set(errp
, QERR_INVALID_BLOCK_FORMAT
, format
);
794 goto delete_and_fail
;
797 proto_drv
= bdrv_find_protocol(snapshot_file
);
799 error_set(errp
, QERR_INVALID_BLOCK_FORMAT
, format
);
800 goto delete_and_fail
;
803 /* create new image w/backing file */
804 ret
= bdrv_img_create(snapshot_file
, format
,
805 states
->old_bs
->filename
,
806 states
->old_bs
->drv
->format_name
,
809 error_set(errp
, QERR_OPEN_FILE_FAILED
, snapshot_file
);
810 goto delete_and_fail
;
813 /* We will manually add the backing_hd field to the bs later */
814 states
->new_bs
= bdrv_new("");
815 ret
= bdrv_open(states
->new_bs
, snapshot_file
,
816 flags
| BDRV_O_NO_BACKING
, drv
);
818 error_set(errp
, QERR_OPEN_FILE_FAILED
, snapshot_file
);
819 goto delete_and_fail
;
824 /* Now we are going to do the actual pivot. Everything up to this point
825 * is reversible, but we are committed at this point */
826 QSIMPLEQ_FOREACH(states
, &snap_bdrv_states
, entry
) {
827 /* This removes our old bs from the bdrv_states, and adds the new bs */
828 bdrv_append(states
->new_bs
, states
->old_bs
);
836 * failure, and it is all-or-none; abandon each new bs, and keep using
837 * the original bs for all images
839 QSIMPLEQ_FOREACH(states
, &snap_bdrv_states
, entry
) {
840 if (states
->new_bs
) {
841 bdrv_delete(states
->new_bs
);
845 QSIMPLEQ_FOREACH(states
, &snap_bdrv_states
, entry
) {
852 static void eject_device(BlockDriverState
*bs
, int force
, Error
**errp
)
854 if (bdrv_in_use(bs
)) {
855 error_set(errp
, QERR_DEVICE_IN_USE
, bdrv_get_device_name(bs
));
858 if (!bdrv_dev_has_removable_media(bs
)) {
859 error_set(errp
, QERR_DEVICE_NOT_REMOVABLE
, bdrv_get_device_name(bs
));
863 if (bdrv_dev_is_medium_locked(bs
) && !bdrv_dev_is_tray_open(bs
)) {
864 bdrv_dev_eject_request(bs
, force
);
866 error_set(errp
, QERR_DEVICE_LOCKED
, bdrv_get_device_name(bs
));
874 void qmp_eject(const char *device
, bool has_force
, bool force
, Error
**errp
)
876 BlockDriverState
*bs
;
878 bs
= bdrv_find(device
);
880 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
884 eject_device(bs
, force
, errp
);
887 void qmp_block_passwd(const char *device
, const char *password
, Error
**errp
)
889 BlockDriverState
*bs
;
892 bs
= bdrv_find(device
);
894 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
898 err
= bdrv_set_key(bs
, password
);
899 if (err
== -EINVAL
) {
900 error_set(errp
, QERR_DEVICE_NOT_ENCRYPTED
, bdrv_get_device_name(bs
));
902 } else if (err
< 0) {
903 error_set(errp
, QERR_INVALID_PASSWORD
);
908 static void qmp_bdrv_open_encrypted(BlockDriverState
*bs
, const char *filename
,
909 int bdrv_flags
, BlockDriver
*drv
,
910 const char *password
, Error
**errp
)
912 if (bdrv_open(bs
, filename
, bdrv_flags
, drv
) < 0) {
913 error_set(errp
, QERR_OPEN_FILE_FAILED
, filename
);
917 if (bdrv_key_required(bs
)) {
919 if (bdrv_set_key(bs
, password
) < 0) {
920 error_set(errp
, QERR_INVALID_PASSWORD
);
923 error_set(errp
, QERR_DEVICE_ENCRYPTED
, bdrv_get_device_name(bs
),
924 bdrv_get_encrypted_filename(bs
));
926 } else if (password
) {
927 error_set(errp
, QERR_DEVICE_NOT_ENCRYPTED
, bdrv_get_device_name(bs
));
931 void qmp_change_blockdev(const char *device
, const char *filename
,
932 bool has_format
, const char *format
, Error
**errp
)
934 BlockDriverState
*bs
;
935 BlockDriver
*drv
= NULL
;
939 bs
= bdrv_find(device
);
941 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
946 drv
= bdrv_find_whitelisted_format(format
);
948 error_set(errp
, QERR_INVALID_BLOCK_FORMAT
, format
);
953 eject_device(bs
, 0, &err
);
954 if (error_is_set(&err
)) {
955 error_propagate(errp
, err
);
959 bdrv_flags
= bdrv_is_read_only(bs
) ? 0 : BDRV_O_RDWR
;
960 bdrv_flags
|= bdrv_is_snapshot(bs
) ? BDRV_O_SNAPSHOT
: 0;
962 qmp_bdrv_open_encrypted(bs
, filename
, bdrv_flags
, drv
, NULL
, errp
);
965 /* throttling disk I/O limits */
966 void qmp_block_set_io_throttle(const char *device
, int64_t bps
, int64_t bps_rd
,
967 int64_t bps_wr
, int64_t iops
, int64_t iops_rd
,
968 int64_t iops_wr
, Error
**errp
)
970 BlockIOLimit io_limits
;
971 BlockDriverState
*bs
;
973 bs
= bdrv_find(device
);
975 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
979 io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
] = bps
;
980 io_limits
.bps
[BLOCK_IO_LIMIT_READ
] = bps_rd
;
981 io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
] = bps_wr
;
982 io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]= iops
;
983 io_limits
.iops
[BLOCK_IO_LIMIT_READ
] = iops_rd
;
984 io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
]= iops_wr
;
986 if (!do_check_io_limits(&io_limits
)) {
987 error_set(errp
, QERR_INVALID_PARAMETER_COMBINATION
);
991 bs
->io_limits
= io_limits
;
992 bs
->slice_time
= BLOCK_IO_SLICE_TIME
;
994 if (!bs
->io_limits_enabled
&& bdrv_io_limits_enabled(bs
)) {
995 bdrv_io_limits_enable(bs
);
996 } else if (bs
->io_limits_enabled
&& !bdrv_io_limits_enabled(bs
)) {
997 bdrv_io_limits_disable(bs
);
999 if (bs
->block_timer
) {
1000 qemu_mod_timer(bs
->block_timer
, qemu_get_clock_ns(vm_clock
));
1005 int do_drive_del(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
1007 const char *id
= qdict_get_str(qdict
, "id");
1008 BlockDriverState
*bs
;
1012 qerror_report(QERR_DEVICE_NOT_FOUND
, id
);
1015 if (bdrv_in_use(bs
)) {
1016 qerror_report(QERR_DEVICE_IN_USE
, id
);
1020 /* quiesce block driver; prevent further io */
1025 /* if we have a device attached to this BlockDriverState
1026 * then we need to make the drive anonymous until the device
1027 * can be removed. If this is a drive with no device backing
1028 * then we can just get rid of the block driver state right here.
1030 if (bdrv_get_attached_dev(bs
)) {
1033 drive_uninit(drive_get_by_blockdev(bs
));
1039 void qmp_block_resize(const char *device
, int64_t size
, Error
**errp
)
1041 BlockDriverState
*bs
;
1043 bs
= bdrv_find(device
);
1045 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
1050 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "size", "a >0 size");
1054 switch (bdrv_truncate(bs
, size
)) {
1058 error_set(errp
, QERR_DEVICE_HAS_NO_MEDIUM
, device
);
1061 error_set(errp
, QERR_UNSUPPORTED
);
1064 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
, device
);
1067 error_set(errp
, QERR_DEVICE_IN_USE
, device
);
1070 error_set(errp
, QERR_UNDEFINED_ERROR
);
1075 static QObject
*qobject_from_block_job(BlockJob
*job
)
1077 return qobject_from_jsonf("{ 'type': %s,"
1079 "'len': %" PRId64
","
1080 "'offset': %" PRId64
","
1081 "'speed': %" PRId64
" }",
1082 job
->job_type
->job_type
,
1083 bdrv_get_device_name(job
->bs
),
1089 static void block_stream_cb(void *opaque
, int ret
)
1091 BlockDriverState
*bs
= opaque
;
1094 trace_block_stream_cb(bs
, bs
->job
, ret
);
1097 obj
= qobject_from_block_job(bs
->job
);
1099 QDict
*dict
= qobject_to_qdict(obj
);
1100 qdict_put(dict
, "error", qstring_from_str(strerror(-ret
)));
1103 if (block_job_is_cancelled(bs
->job
)) {
1104 monitor_protocol_event(QEVENT_BLOCK_JOB_CANCELLED
, obj
);
1106 monitor_protocol_event(QEVENT_BLOCK_JOB_COMPLETED
, obj
);
1108 qobject_decref(obj
);
1110 drive_put_ref_bh_schedule(drive_get_by_blockdev(bs
));
1113 void qmp_block_stream(const char *device
, bool has_base
,
1114 const char *base
, Error
**errp
)
1116 BlockDriverState
*bs
;
1117 BlockDriverState
*base_bs
= NULL
;
1120 bs
= bdrv_find(device
);
1122 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
1127 base_bs
= bdrv_find_backing_image(bs
, base
);
1128 if (base_bs
== NULL
) {
1129 error_set(errp
, QERR_BASE_NOT_FOUND
, base
);
1134 ret
= stream_start(bs
, base_bs
, base
, block_stream_cb
, bs
);
1138 error_set(errp
, QERR_DEVICE_IN_USE
, device
);
1141 error_set(errp
, QERR_NOT_SUPPORTED
);
1146 /* Grab a reference so hotplug does not delete the BlockDriverState from
1149 drive_get_ref(drive_get_by_blockdev(bs
));
1151 trace_qmp_block_stream(bs
, bs
->job
);
1154 static BlockJob
*find_block_job(const char *device
)
1156 BlockDriverState
*bs
;
1158 bs
= bdrv_find(device
);
1159 if (!bs
|| !bs
->job
) {
1165 void qmp_block_job_set_speed(const char *device
, int64_t value
, Error
**errp
)
1167 BlockJob
*job
= find_block_job(device
);
1170 error_set(errp
, QERR_DEVICE_NOT_ACTIVE
, device
);
1174 if (block_job_set_speed(job
, value
) < 0) {
1175 error_set(errp
, QERR_NOT_SUPPORTED
);
1179 void qmp_block_job_cancel(const char *device
, Error
**errp
)
1181 BlockJob
*job
= find_block_job(device
);
1184 error_set(errp
, QERR_DEVICE_NOT_ACTIVE
, device
);
1188 trace_qmp_block_job_cancel(job
);
1189 block_job_cancel(job
);
1192 static void do_qmp_query_block_jobs_one(void *opaque
, BlockDriverState
*bs
)
1194 BlockJobInfoList
**prev
= opaque
;
1195 BlockJob
*job
= bs
->job
;
1198 BlockJobInfoList
*elem
;
1199 BlockJobInfo
*info
= g_new(BlockJobInfo
, 1);
1200 *info
= (BlockJobInfo
){
1201 .type
= g_strdup(job
->job_type
->job_type
),
1202 .device
= g_strdup(bdrv_get_device_name(bs
)),
1204 .offset
= job
->offset
,
1205 .speed
= job
->speed
,
1208 elem
= g_new0(BlockJobInfoList
, 1);
1211 (*prev
)->next
= elem
;
1216 BlockJobInfoList
*qmp_query_block_jobs(Error
**errp
)
1218 /* Dummy is a fake list element for holding the head pointer */
1219 BlockJobInfoList dummy
= {};
1220 BlockJobInfoList
*prev
= &dummy
;
1221 bdrv_iterate(do_qmp_query_block_jobs_one
, &prev
);