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"
22 static QTAILQ_HEAD(drivelist
, DriveInfo
) drives
= QTAILQ_HEAD_INITIALIZER(drives
);
24 static const char *const if_name
[IF_COUNT
] = {
28 [IF_FLOPPY
] = "floppy",
29 [IF_PFLASH
] = "pflash",
32 [IF_VIRTIO
] = "virtio",
36 static const int if_max_devs
[IF_COUNT
] = {
38 * Do not change these numbers! They govern how drive option
39 * index maps to unit and bus. That mapping is ABI.
41 * All controllers used to imlement if=T drives need to support
42 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
43 * Otherwise, some index values map to "impossible" bus, unit
46 * For instance, if you change [IF_SCSI] to 255, -drive
47 * if=scsi,index=12 no longer means bus=1,unit=5, but
48 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
49 * the drive can't be set up. Regression.
56 * We automatically delete the drive when a device using it gets
57 * unplugged. Questionable feature, but we can't just drop it.
58 * Device models call blockdev_mark_auto_del() to schedule the
59 * automatic deletion, and generic qdev code calls blockdev_auto_del()
60 * when deletion is actually safe.
62 void blockdev_mark_auto_del(BlockDriverState
*bs
)
64 DriveInfo
*dinfo
= drive_get_by_blockdev(bs
);
71 void blockdev_auto_del(BlockDriverState
*bs
)
73 DriveInfo
*dinfo
= drive_get_by_blockdev(bs
);
75 if (dinfo
&& dinfo
->auto_del
) {
80 static int drive_index_to_bus_id(BlockInterfaceType type
, int index
)
82 int max_devs
= if_max_devs
[type
];
83 return max_devs
? index
/ max_devs
: 0;
86 static int drive_index_to_unit_id(BlockInterfaceType type
, int index
)
88 int max_devs
= if_max_devs
[type
];
89 return max_devs
? index
% max_devs
: index
;
92 QemuOpts
*drive_def(const char *optstr
)
94 return qemu_opts_parse(qemu_find_opts("drive"), optstr
, 0);
97 QemuOpts
*drive_add(BlockInterfaceType type
, int index
, const char *file
,
103 opts
= drive_def(optstr
);
107 if (type
!= IF_DEFAULT
) {
108 qemu_opt_set(opts
, "if", if_name
[type
]);
111 snprintf(buf
, sizeof(buf
), "%d", index
);
112 qemu_opt_set(opts
, "index", buf
);
115 qemu_opt_set(opts
, "file", file
);
119 DriveInfo
*drive_get(BlockInterfaceType type
, int bus
, int unit
)
123 /* seek interface, bus and unit */
125 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
126 if (dinfo
->type
== type
&&
135 DriveInfo
*drive_get_by_index(BlockInterfaceType type
, int index
)
137 return drive_get(type
,
138 drive_index_to_bus_id(type
, index
),
139 drive_index_to_unit_id(type
, index
));
142 int drive_get_max_bus(BlockInterfaceType type
)
148 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
149 if(dinfo
->type
== type
&&
150 dinfo
->bus
> max_bus
)
151 max_bus
= dinfo
->bus
;
156 /* Get a block device. This should only be used for single-drive devices
157 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
159 DriveInfo
*drive_get_next(BlockInterfaceType type
)
161 static int next_block_unit
[IF_COUNT
];
163 return drive_get(type
, 0, next_block_unit
[type
]++);
166 DriveInfo
*drive_get_by_blockdev(BlockDriverState
*bs
)
170 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
171 if (dinfo
->bdrv
== bs
) {
178 static void bdrv_format_print(void *opaque
, const char *name
)
180 error_printf(" %s", name
);
183 static void drive_uninit(DriveInfo
*dinfo
)
185 qemu_opts_del(dinfo
->opts
);
186 bdrv_delete(dinfo
->bdrv
);
188 QTAILQ_REMOVE(&drives
, dinfo
, next
);
192 void drive_put_ref(DriveInfo
*dinfo
)
194 assert(dinfo
->refcount
);
195 if (--dinfo
->refcount
== 0) {
200 void drive_get_ref(DriveInfo
*dinfo
)
205 static int parse_block_error_action(const char *buf
, int is_read
)
207 if (!strcmp(buf
, "ignore")) {
208 return BLOCK_ERR_IGNORE
;
209 } else if (!is_read
&& !strcmp(buf
, "enospc")) {
210 return BLOCK_ERR_STOP_ENOSPC
;
211 } else if (!strcmp(buf
, "stop")) {
212 return BLOCK_ERR_STOP_ANY
;
213 } else if (!strcmp(buf
, "report")) {
214 return BLOCK_ERR_REPORT
;
216 error_report("'%s' invalid %s error action",
217 buf
, is_read
? "read" : "write");
222 static bool do_check_io_limits(BlockIOLimit
*io_limits
)
229 bps_flag
= (io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
] != 0)
230 && ((io_limits
->bps
[BLOCK_IO_LIMIT_READ
] != 0)
231 || (io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
] != 0));
232 iops_flag
= (io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
] != 0)
233 && ((io_limits
->iops
[BLOCK_IO_LIMIT_READ
] != 0)
234 || (io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
] != 0));
235 if (bps_flag
|| iops_flag
) {
242 DriveInfo
*drive_init(QemuOpts
*opts
, int default_to_scsi
)
245 const char *file
= NULL
;
248 const char *mediastr
= "";
249 BlockInterfaceType type
;
250 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
252 int cyls
, heads
, secs
, translation
;
253 BlockDriver
*drv
= NULL
;
258 int on_read_error
, on_write_error
;
261 BlockIOLimit io_limits
;
266 translation
= BIOS_ATA_TRANSLATION_AUTO
;
269 /* extract parameters */
270 bus_id
= qemu_opt_get_number(opts
, "bus", 0);
271 unit_id
= qemu_opt_get_number(opts
, "unit", -1);
272 index
= qemu_opt_get_number(opts
, "index", -1);
274 cyls
= qemu_opt_get_number(opts
, "cyls", 0);
275 heads
= qemu_opt_get_number(opts
, "heads", 0);
276 secs
= qemu_opt_get_number(opts
, "secs", 0);
278 snapshot
= qemu_opt_get_bool(opts
, "snapshot", 0);
279 ro
= qemu_opt_get_bool(opts
, "readonly", 0);
280 copy_on_read
= qemu_opt_get_bool(opts
, "copy-on-read", false);
282 file
= qemu_opt_get(opts
, "file");
283 serial
= qemu_opt_get(opts
, "serial");
285 if ((buf
= qemu_opt_get(opts
, "if")) != NULL
) {
286 pstrcpy(devname
, sizeof(devname
), buf
);
287 for (type
= 0; type
< IF_COUNT
&& strcmp(buf
, if_name
[type
]); type
++)
289 if (type
== IF_COUNT
) {
290 error_report("unsupported bus type '%s'", buf
);
294 type
= default_to_scsi
? IF_SCSI
: IF_IDE
;
295 pstrcpy(devname
, sizeof(devname
), if_name
[type
]);
298 max_devs
= if_max_devs
[type
];
300 if (cyls
|| heads
|| secs
) {
301 if (cyls
< 1 || (type
== IF_IDE
&& cyls
> 16383)) {
302 error_report("invalid physical cyls number");
305 if (heads
< 1 || (type
== IF_IDE
&& heads
> 16)) {
306 error_report("invalid physical heads number");
309 if (secs
< 1 || (type
== IF_IDE
&& secs
> 63)) {
310 error_report("invalid physical secs number");
315 if ((buf
= qemu_opt_get(opts
, "trans")) != NULL
) {
317 error_report("'%s' trans must be used with cyls, heads and secs",
321 if (!strcmp(buf
, "none"))
322 translation
= BIOS_ATA_TRANSLATION_NONE
;
323 else if (!strcmp(buf
, "lba"))
324 translation
= BIOS_ATA_TRANSLATION_LBA
;
325 else if (!strcmp(buf
, "auto"))
326 translation
= BIOS_ATA_TRANSLATION_AUTO
;
328 error_report("'%s' invalid translation type", buf
);
333 if ((buf
= qemu_opt_get(opts
, "media")) != NULL
) {
334 if (!strcmp(buf
, "disk")) {
336 } else if (!strcmp(buf
, "cdrom")) {
337 if (cyls
|| secs
|| heads
) {
338 error_report("CHS can't be set with media=%s", buf
);
343 error_report("'%s' invalid media", buf
);
348 if ((buf
= qemu_opt_get(opts
, "cache")) != NULL
) {
349 if (bdrv_parse_cache_flags(buf
, &bdrv_flags
) != 0) {
350 error_report("invalid cache option");
355 #ifdef CONFIG_LINUX_AIO
356 if ((buf
= qemu_opt_get(opts
, "aio")) != NULL
) {
357 if (!strcmp(buf
, "native")) {
358 bdrv_flags
|= BDRV_O_NATIVE_AIO
;
359 } else if (!strcmp(buf
, "threads")) {
360 /* this is the default */
362 error_report("invalid aio option");
368 if ((buf
= qemu_opt_get(opts
, "format")) != NULL
) {
369 if (strcmp(buf
, "?") == 0) {
370 error_printf("Supported formats:");
371 bdrv_iterate_format(bdrv_format_print
, NULL
);
375 drv
= bdrv_find_whitelisted_format(buf
);
377 error_report("'%s' invalid format", buf
);
382 /* disk I/O throttling */
383 io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
] =
384 qemu_opt_get_number(opts
, "bps", 0);
385 io_limits
.bps
[BLOCK_IO_LIMIT_READ
] =
386 qemu_opt_get_number(opts
, "bps_rd", 0);
387 io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
] =
388 qemu_opt_get_number(opts
, "bps_wr", 0);
389 io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
] =
390 qemu_opt_get_number(opts
, "iops", 0);
391 io_limits
.iops
[BLOCK_IO_LIMIT_READ
] =
392 qemu_opt_get_number(opts
, "iops_rd", 0);
393 io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
] =
394 qemu_opt_get_number(opts
, "iops_wr", 0);
396 if (!do_check_io_limits(&io_limits
)) {
397 error_report("bps(iops) and bps_rd/bps_wr(iops_rd/iops_wr) "
398 "cannot be used at the same time");
402 on_write_error
= BLOCK_ERR_STOP_ENOSPC
;
403 if ((buf
= qemu_opt_get(opts
, "werror")) != NULL
) {
404 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
&& type
!= IF_NONE
) {
405 error_report("werror is not supported by this bus type");
409 on_write_error
= parse_block_error_action(buf
, 0);
410 if (on_write_error
< 0) {
415 on_read_error
= BLOCK_ERR_REPORT
;
416 if ((buf
= qemu_opt_get(opts
, "rerror")) != NULL
) {
417 if (type
!= IF_IDE
&& type
!= IF_VIRTIO
&& type
!= IF_SCSI
&& type
!= IF_NONE
) {
418 error_report("rerror is not supported by this bus type");
422 on_read_error
= parse_block_error_action(buf
, 1);
423 if (on_read_error
< 0) {
428 if ((devaddr
= qemu_opt_get(opts
, "addr")) != NULL
) {
429 if (type
!= IF_VIRTIO
) {
430 error_report("addr is not supported by this bus type");
435 /* compute bus and unit according index */
438 if (bus_id
!= 0 || unit_id
!= -1) {
439 error_report("index cannot be used with bus and unit");
442 bus_id
= drive_index_to_bus_id(type
, index
);
443 unit_id
= drive_index_to_unit_id(type
, index
);
446 /* if user doesn't specify a unit_id,
447 * try to find the first free
452 while (drive_get(type
, bus_id
, unit_id
) != NULL
) {
454 if (max_devs
&& unit_id
>= max_devs
) {
463 if (max_devs
&& unit_id
>= max_devs
) {
464 error_report("unit %d too big (max is %d)",
465 unit_id
, max_devs
- 1);
470 * catch multiple definitions
473 if (drive_get(type
, bus_id
, unit_id
) != NULL
) {
474 error_report("drive with bus=%d, unit=%d (index=%d) exists",
475 bus_id
, unit_id
, index
);
481 dinfo
= g_malloc0(sizeof(*dinfo
));
482 if ((buf
= qemu_opts_id(opts
)) != NULL
) {
483 dinfo
->id
= g_strdup(buf
);
485 /* no id supplied -> create one */
486 dinfo
->id
= g_malloc0(32);
487 if (type
== IF_IDE
|| type
== IF_SCSI
)
488 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
490 snprintf(dinfo
->id
, 32, "%s%i%s%i",
491 devname
, bus_id
, mediastr
, unit_id
);
493 snprintf(dinfo
->id
, 32, "%s%s%i",
494 devname
, mediastr
, unit_id
);
496 dinfo
->bdrv
= bdrv_new(dinfo
->id
);
497 dinfo
->devaddr
= devaddr
;
500 dinfo
->unit
= unit_id
;
504 strncpy(dinfo
->serial
, serial
, sizeof(dinfo
->serial
) - 1);
505 QTAILQ_INSERT_TAIL(&drives
, dinfo
, next
);
507 bdrv_set_on_error(dinfo
->bdrv
, on_read_error
, on_write_error
);
509 /* disk I/O throttling */
510 bdrv_set_io_limits(dinfo
->bdrv
, &io_limits
);
520 bdrv_set_geometry_hint(dinfo
->bdrv
, cyls
, heads
, secs
);
521 bdrv_set_translation_hint(dinfo
->bdrv
, translation
);
535 /* add virtio block device */
536 opts
= qemu_opts_create(qemu_find_opts("device"), NULL
, 0);
537 qemu_opt_set(opts
, "driver", "virtio-blk");
538 qemu_opt_set(opts
, "drive", dinfo
->id
);
540 qemu_opt_set(opts
, "addr", devaddr
);
545 if (!file
|| !*file
) {
549 /* always use cache=unsafe with snapshot */
550 bdrv_flags
&= ~BDRV_O_CACHE_MASK
;
551 bdrv_flags
|= (BDRV_O_SNAPSHOT
|BDRV_O_CACHE_WB
|BDRV_O_NO_FLUSH
);
555 bdrv_flags
|= BDRV_O_COPY_ON_READ
;
558 if (media
== MEDIA_CDROM
) {
559 /* CDROM is fine for any interface, don't check. */
561 } else if (ro
== 1) {
562 if (type
!= IF_SCSI
&& type
!= IF_VIRTIO
&& type
!= IF_FLOPPY
&& type
!= IF_NONE
) {
563 error_report("readonly not supported by this bus type");
568 bdrv_flags
|= ro
? 0 : BDRV_O_RDWR
;
570 ret
= bdrv_open(dinfo
->bdrv
, file
, bdrv_flags
, drv
);
572 error_report("could not open disk image %s: %s",
573 file
, strerror(-ret
));
577 if (bdrv_key_required(dinfo
->bdrv
))
582 bdrv_delete(dinfo
->bdrv
);
584 QTAILQ_REMOVE(&drives
, dinfo
, next
);
589 void do_commit(Monitor
*mon
, const QDict
*qdict
)
591 const char *device
= qdict_get_str(qdict
, "device");
592 BlockDriverState
*bs
;
594 if (!strcmp(device
, "all")) {
599 bs
= bdrv_find(device
);
601 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
604 ret
= bdrv_commit(bs
);
606 qerror_report(QERR_DEVICE_IN_USE
, device
);
612 void qmp_blockdev_snapshot_sync(const char *device
, const char *snapshot_file
,
613 bool has_format
, const char *format
,
616 BlockDriverState
*bs
;
617 BlockDriver
*drv
, *old_drv
, *proto_drv
;
620 char old_filename
[1024];
622 bs
= bdrv_find(device
);
624 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
627 if (bdrv_in_use(bs
)) {
628 error_set(errp
, QERR_DEVICE_IN_USE
, device
);
632 pstrcpy(old_filename
, sizeof(old_filename
), bs
->filename
);
635 flags
= bs
->open_flags
;
641 drv
= bdrv_find_format(format
);
643 error_set(errp
, QERR_INVALID_BLOCK_FORMAT
, format
);
647 proto_drv
= bdrv_find_protocol(snapshot_file
);
649 error_set(errp
, QERR_INVALID_BLOCK_FORMAT
, format
);
653 ret
= bdrv_img_create(snapshot_file
, format
, bs
->filename
,
654 bs
->drv
->format_name
, NULL
, -1, flags
);
656 error_set(errp
, QERR_UNDEFINED_ERROR
);
664 ret
= bdrv_open(bs
, snapshot_file
, flags
, drv
);
666 * If reopening the image file we just created fails, fall back
667 * and try to re-open the original image. If that fails too, we
668 * are in serious trouble.
671 ret
= bdrv_open(bs
, old_filename
, flags
, old_drv
);
673 error_set(errp
, QERR_OPEN_FILE_FAILED
, old_filename
);
675 error_set(errp
, QERR_OPEN_FILE_FAILED
, snapshot_file
);
680 static void eject_device(BlockDriverState
*bs
, int force
, Error
**errp
)
682 if (bdrv_in_use(bs
)) {
683 error_set(errp
, QERR_DEVICE_IN_USE
, bdrv_get_device_name(bs
));
686 if (!bdrv_dev_has_removable_media(bs
)) {
687 error_set(errp
, QERR_DEVICE_NOT_REMOVABLE
, bdrv_get_device_name(bs
));
691 if (bdrv_dev_is_medium_locked(bs
) && !bdrv_dev_is_tray_open(bs
)) {
692 bdrv_dev_eject_request(bs
, force
);
694 error_set(errp
, QERR_DEVICE_LOCKED
, bdrv_get_device_name(bs
));
702 void qmp_eject(const char *device
, bool has_force
, bool force
, Error
**errp
)
704 BlockDriverState
*bs
;
706 bs
= bdrv_find(device
);
708 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
712 eject_device(bs
, force
, errp
);
715 void qmp_block_passwd(const char *device
, const char *password
, Error
**errp
)
717 BlockDriverState
*bs
;
720 bs
= bdrv_find(device
);
722 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
726 err
= bdrv_set_key(bs
, password
);
727 if (err
== -EINVAL
) {
728 error_set(errp
, QERR_DEVICE_NOT_ENCRYPTED
, bdrv_get_device_name(bs
));
730 } else if (err
< 0) {
731 error_set(errp
, QERR_INVALID_PASSWORD
);
736 static void qmp_bdrv_open_encrypted(BlockDriverState
*bs
, const char *filename
,
737 int bdrv_flags
, BlockDriver
*drv
,
738 const char *password
, Error
**errp
)
740 if (bdrv_open(bs
, filename
, bdrv_flags
, drv
) < 0) {
741 error_set(errp
, QERR_OPEN_FILE_FAILED
, filename
);
745 if (bdrv_key_required(bs
)) {
747 if (bdrv_set_key(bs
, password
) < 0) {
748 error_set(errp
, QERR_INVALID_PASSWORD
);
751 error_set(errp
, QERR_DEVICE_ENCRYPTED
, bdrv_get_device_name(bs
),
752 bdrv_get_encrypted_filename(bs
));
754 } else if (password
) {
755 error_set(errp
, QERR_DEVICE_NOT_ENCRYPTED
, bdrv_get_device_name(bs
));
759 void qmp_change_blockdev(const char *device
, const char *filename
,
760 bool has_format
, const char *format
, Error
**errp
)
762 BlockDriverState
*bs
;
763 BlockDriver
*drv
= NULL
;
767 bs
= bdrv_find(device
);
769 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
774 drv
= bdrv_find_whitelisted_format(format
);
776 error_set(errp
, QERR_INVALID_BLOCK_FORMAT
, format
);
781 eject_device(bs
, 0, &err
);
782 if (error_is_set(&err
)) {
783 error_propagate(errp
, err
);
787 bdrv_flags
= bdrv_is_read_only(bs
) ? 0 : BDRV_O_RDWR
;
788 bdrv_flags
|= bdrv_is_snapshot(bs
) ? BDRV_O_SNAPSHOT
: 0;
790 qmp_bdrv_open_encrypted(bs
, filename
, bdrv_flags
, drv
, NULL
, errp
);
793 /* throttling disk I/O limits */
794 void qmp_block_set_io_throttle(const char *device
, int64_t bps
, int64_t bps_rd
,
795 int64_t bps_wr
, int64_t iops
, int64_t iops_rd
,
796 int64_t iops_wr
, Error
**errp
)
798 BlockIOLimit io_limits
;
799 BlockDriverState
*bs
;
801 bs
= bdrv_find(device
);
803 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
807 io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
] = bps
;
808 io_limits
.bps
[BLOCK_IO_LIMIT_READ
] = bps_rd
;
809 io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
] = bps_wr
;
810 io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]= iops
;
811 io_limits
.iops
[BLOCK_IO_LIMIT_READ
] = iops_rd
;
812 io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
]= iops_wr
;
814 if (!do_check_io_limits(&io_limits
)) {
815 error_set(errp
, QERR_INVALID_PARAMETER_COMBINATION
);
819 bs
->io_limits
= io_limits
;
820 bs
->slice_time
= BLOCK_IO_SLICE_TIME
;
822 if (!bs
->io_limits_enabled
&& bdrv_io_limits_enabled(bs
)) {
823 bdrv_io_limits_enable(bs
);
824 } else if (bs
->io_limits_enabled
&& !bdrv_io_limits_enabled(bs
)) {
825 bdrv_io_limits_disable(bs
);
827 if (bs
->block_timer
) {
828 qemu_mod_timer(bs
->block_timer
, qemu_get_clock_ns(vm_clock
));
833 int do_drive_del(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
835 const char *id
= qdict_get_str(qdict
, "id");
836 BlockDriverState
*bs
;
840 qerror_report(QERR_DEVICE_NOT_FOUND
, id
);
843 if (bdrv_in_use(bs
)) {
844 qerror_report(QERR_DEVICE_IN_USE
, id
);
848 /* quiesce block driver; prevent further io */
853 /* if we have a device attached to this BlockDriverState
854 * then we need to make the drive anonymous until the device
855 * can be removed. If this is a drive with no device backing
856 * then we can just get rid of the block driver state right here.
858 if (bdrv_get_attached_dev(bs
)) {
861 drive_uninit(drive_get_by_blockdev(bs
));
867 void qmp_block_resize(const char *device
, int64_t size
, Error
**errp
)
869 BlockDriverState
*bs
;
871 bs
= bdrv_find(device
);
873 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
878 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "size", "a >0 size");
882 switch (bdrv_truncate(bs
, size
)) {
886 error_set(errp
, QERR_DEVICE_HAS_NO_MEDIUM
, device
);
889 error_set(errp
, QERR_UNSUPPORTED
);
892 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
, device
);
895 error_set(errp
, QERR_DEVICE_IN_USE
, device
);
898 error_set(errp
, QERR_UNDEFINED_ERROR
);
903 static QObject
*qobject_from_block_job(BlockJob
*job
)
905 return qobject_from_jsonf("{ 'type': %s,"
907 "'len': %" PRId64
","
908 "'offset': %" PRId64
","
909 "'speed': %" PRId64
" }",
910 job
->job_type
->job_type
,
911 bdrv_get_device_name(job
->bs
),
917 static void block_stream_cb(void *opaque
, int ret
)
919 BlockDriverState
*bs
= opaque
;
922 trace_block_stream_cb(bs
, bs
->job
, ret
);
925 obj
= qobject_from_block_job(bs
->job
);
927 QDict
*dict
= qobject_to_qdict(obj
);
928 qdict_put(dict
, "error", qstring_from_str(strerror(-ret
)));
931 monitor_protocol_event(QEVENT_BLOCK_JOB_COMPLETED
, obj
);
935 void qmp_block_stream(const char *device
, bool has_base
,
936 const char *base
, Error
**errp
)
938 BlockDriverState
*bs
;
941 bs
= bdrv_find(device
);
943 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
947 /* Base device not supported */
949 error_set(errp
, QERR_NOT_SUPPORTED
);
953 ret
= stream_start(bs
, NULL
, block_stream_cb
, bs
);
957 error_set(errp
, QERR_DEVICE_IN_USE
, device
);
960 error_set(errp
, QERR_NOT_SUPPORTED
);
965 trace_qmp_block_stream(bs
, bs
->job
);