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"
17 #include "block_int.h"
19 static QTAILQ_HEAD(drivelist
, DriveInfo
) drives
= QTAILQ_HEAD_INITIALIZER(drives
);
21 static const char *const if_name
[IF_COUNT
] = {
25 [IF_FLOPPY
] = "floppy",
26 [IF_PFLASH
] = "pflash",
29 [IF_VIRTIO
] = "virtio",
33 static const int if_max_devs
[IF_COUNT
] = {
35 * Do not change these numbers! They govern how drive option
36 * index maps to unit and bus. That mapping is ABI.
38 * All controllers used to imlement if=T drives need to support
39 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
40 * Otherwise, some index values map to "impossible" bus, unit
43 * For instance, if you change [IF_SCSI] to 255, -drive
44 * if=scsi,index=12 no longer means bus=1,unit=5, but
45 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
46 * the drive can't be set up. Regression.
53 * We automatically delete the drive when a device using it gets
54 * unplugged. Questionable feature, but we can't just drop it.
55 * Device models call blockdev_mark_auto_del() to schedule the
56 * automatic deletion, and generic qdev code calls blockdev_auto_del()
57 * when deletion is actually safe.
59 void blockdev_mark_auto_del(BlockDriverState
*bs
)
61 DriveInfo
*dinfo
= drive_get_by_blockdev(bs
);
68 void blockdev_auto_del(BlockDriverState
*bs
)
70 DriveInfo
*dinfo
= drive_get_by_blockdev(bs
);
72 if (dinfo
&& dinfo
->auto_del
) {
77 static int drive_index_to_bus_id(BlockInterfaceType type
, int index
)
79 int max_devs
= if_max_devs
[type
];
80 return max_devs
? index
/ max_devs
: 0;
83 static int drive_index_to_unit_id(BlockInterfaceType type
, int index
)
85 int max_devs
= if_max_devs
[type
];
86 return max_devs
? index
% max_devs
: index
;
89 QemuOpts
*drive_def(const char *optstr
)
91 return qemu_opts_parse(qemu_find_opts("drive"), optstr
, 0);
94 QemuOpts
*drive_add(BlockInterfaceType type
, int index
, const char *file
,
100 opts
= drive_def(optstr
);
104 if (type
!= IF_DEFAULT
) {
105 qemu_opt_set(opts
, "if", if_name
[type
]);
108 snprintf(buf
, sizeof(buf
), "%d", index
);
109 qemu_opt_set(opts
, "index", buf
);
112 qemu_opt_set(opts
, "file", file
);
116 DriveInfo
*drive_get(BlockInterfaceType type
, int bus
, int unit
)
120 /* seek interface, bus and unit */
122 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
123 if (dinfo
->type
== type
&&
132 DriveInfo
*drive_get_by_index(BlockInterfaceType type
, int index
)
134 return drive_get(type
,
135 drive_index_to_bus_id(type
, index
),
136 drive_index_to_unit_id(type
, index
));
139 int drive_get_max_bus(BlockInterfaceType type
)
145 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
146 if(dinfo
->type
== type
&&
147 dinfo
->bus
> max_bus
)
148 max_bus
= dinfo
->bus
;
153 /* Get a block device. This should only be used for single-drive devices
154 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
156 DriveInfo
*drive_get_next(BlockInterfaceType type
)
158 static int next_block_unit
[IF_COUNT
];
160 return drive_get(type
, 0, next_block_unit
[type
]++);
163 DriveInfo
*drive_get_by_blockdev(BlockDriverState
*bs
)
167 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
168 if (dinfo
->bdrv
== bs
) {
175 static void bdrv_format_print(void *opaque
, const char *name
)
177 error_printf(" %s", name
);
180 static void drive_uninit(DriveInfo
*dinfo
)
182 qemu_opts_del(dinfo
->opts
);
183 bdrv_delete(dinfo
->bdrv
);
185 QTAILQ_REMOVE(&drives
, dinfo
, next
);
189 void drive_put_ref(DriveInfo
*dinfo
)
191 assert(dinfo
->refcount
);
192 if (--dinfo
->refcount
== 0) {
197 void drive_get_ref(DriveInfo
*dinfo
)
202 static int parse_block_error_action(const char *buf
, int is_read
)
204 if (!strcmp(buf
, "ignore")) {
205 return BLOCK_ERR_IGNORE
;
206 } else if (!is_read
&& !strcmp(buf
, "enospc")) {
207 return BLOCK_ERR_STOP_ENOSPC
;
208 } else if (!strcmp(buf
, "stop")) {
209 return BLOCK_ERR_STOP_ANY
;
210 } else if (!strcmp(buf
, "report")) {
211 return BLOCK_ERR_REPORT
;
213 error_report("'%s' invalid %s error action",
214 buf
, is_read
? "read" : "write");
219 static bool do_check_io_limits(BlockIOLimit
*io_limits
)
226 bps_flag
= (io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
] != 0)
227 && ((io_limits
->bps
[BLOCK_IO_LIMIT_READ
] != 0)
228 || (io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
] != 0));
229 iops_flag
= (io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
] != 0)
230 && ((io_limits
->iops
[BLOCK_IO_LIMIT_READ
] != 0)
231 || (io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
] != 0));
232 if (bps_flag
|| iops_flag
) {
239 DriveInfo
*drive_init(QemuOpts
*opts
, int default_to_scsi
)
242 const char *file
= NULL
;
245 const char *mediastr
= "";
246 BlockInterfaceType type
;
247 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
249 int cyls
, heads
, secs
, translation
;
250 BlockDriver
*drv
= NULL
;
255 int on_read_error
, on_write_error
;
258 BlockIOLimit io_limits
;
263 translation
= BIOS_ATA_TRANSLATION_AUTO
;
266 /* extract parameters */
267 bus_id
= qemu_opt_get_number(opts
, "bus", 0);
268 unit_id
= qemu_opt_get_number(opts
, "unit", -1);
269 index
= qemu_opt_get_number(opts
, "index", -1);
271 cyls
= qemu_opt_get_number(opts
, "cyls", 0);
272 heads
= qemu_opt_get_number(opts
, "heads", 0);
273 secs
= qemu_opt_get_number(opts
, "secs", 0);
275 snapshot
= qemu_opt_get_bool(opts
, "snapshot", 0);
276 ro
= qemu_opt_get_bool(opts
, "readonly", 0);
277 copy_on_read
= qemu_opt_get_bool(opts
, "copy-on-read", false);
279 file
= qemu_opt_get(opts
, "file");
280 serial
= qemu_opt_get(opts
, "serial");
282 if ((buf
= qemu_opt_get(opts
, "if")) != NULL
) {
283 pstrcpy(devname
, sizeof(devname
), buf
);
284 for (type
= 0; type
< IF_COUNT
&& strcmp(buf
, if_name
[type
]); type
++)
286 if (type
== IF_COUNT
) {
287 error_report("unsupported bus type '%s'", buf
);
291 type
= default_to_scsi
? IF_SCSI
: IF_IDE
;
292 pstrcpy(devname
, sizeof(devname
), if_name
[type
]);
295 max_devs
= if_max_devs
[type
];
297 if (cyls
|| heads
|| secs
) {
298 if (cyls
< 1 || (type
== IF_IDE
&& cyls
> 16383)) {
299 error_report("invalid physical cyls number");
302 if (heads
< 1 || (type
== IF_IDE
&& heads
> 16)) {
303 error_report("invalid physical heads number");
306 if (secs
< 1 || (type
== IF_IDE
&& secs
> 63)) {
307 error_report("invalid physical secs number");
312 if ((buf
= qemu_opt_get(opts
, "trans")) != NULL
) {
314 error_report("'%s' trans must be used with cyls, heads and secs",
318 if (!strcmp(buf
, "none"))
319 translation
= BIOS_ATA_TRANSLATION_NONE
;
320 else if (!strcmp(buf
, "lba"))
321 translation
= BIOS_ATA_TRANSLATION_LBA
;
322 else if (!strcmp(buf
, "auto"))
323 translation
= BIOS_ATA_TRANSLATION_AUTO
;
325 error_report("'%s' invalid translation type", buf
);
330 if ((buf
= qemu_opt_get(opts
, "media")) != NULL
) {
331 if (!strcmp(buf
, "disk")) {
333 } else if (!strcmp(buf
, "cdrom")) {
334 if (cyls
|| secs
|| heads
) {
335 error_report("CHS can't be set with media=%s", buf
);
340 error_report("'%s' invalid media", buf
);
345 if ((buf
= qemu_opt_get(opts
, "cache")) != NULL
) {
346 if (bdrv_parse_cache_flags(buf
, &bdrv_flags
) != 0) {
347 error_report("invalid cache option");
352 #ifdef CONFIG_LINUX_AIO
353 if ((buf
= qemu_opt_get(opts
, "aio")) != NULL
) {
354 if (!strcmp(buf
, "native")) {
355 bdrv_flags
|= BDRV_O_NATIVE_AIO
;
356 } else if (!strcmp(buf
, "threads")) {
357 /* this is the default */
359 error_report("invalid aio option");
365 if ((buf
= qemu_opt_get(opts
, "format")) != NULL
) {
366 if (strcmp(buf
, "?") == 0) {
367 error_printf("Supported formats:");
368 bdrv_iterate_format(bdrv_format_print
, NULL
);
372 drv
= bdrv_find_whitelisted_format(buf
);
374 error_report("'%s' invalid format", buf
);
379 /* disk I/O throttling */
380 io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
] =
381 qemu_opt_get_number(opts
, "bps", 0);
382 io_limits
.bps
[BLOCK_IO_LIMIT_READ
] =
383 qemu_opt_get_number(opts
, "bps_rd", 0);
384 io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
] =
385 qemu_opt_get_number(opts
, "bps_wr", 0);
386 io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
] =
387 qemu_opt_get_number(opts
, "iops", 0);
388 io_limits
.iops
[BLOCK_IO_LIMIT_READ
] =
389 qemu_opt_get_number(opts
, "iops_rd", 0);
390 io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
] =
391 qemu_opt_get_number(opts
, "iops_wr", 0);
393 if (!do_check_io_limits(&io_limits
)) {
394 error_report("bps(iops) and bps_rd/bps_wr(iops_rd/iops_wr) "
395 "cannot be used at the same time");
399 on_write_error
= BLOCK_ERR_STOP_ENOSPC
;
400 if ((buf
= qemu_opt_get(opts
, "werror")) != NULL
) {
401 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
&& type
!= IF_NONE
) {
402 error_report("werror is not supported by this bus type");
406 on_write_error
= parse_block_error_action(buf
, 0);
407 if (on_write_error
< 0) {
412 on_read_error
= BLOCK_ERR_REPORT
;
413 if ((buf
= qemu_opt_get(opts
, "rerror")) != NULL
) {
414 if (type
!= IF_IDE
&& type
!= IF_VIRTIO
&& type
!= IF_SCSI
&& type
!= IF_NONE
) {
415 error_report("rerror is not supported by this bus type");
419 on_read_error
= parse_block_error_action(buf
, 1);
420 if (on_read_error
< 0) {
425 if ((devaddr
= qemu_opt_get(opts
, "addr")) != NULL
) {
426 if (type
!= IF_VIRTIO
) {
427 error_report("addr is not supported by this bus type");
432 /* compute bus and unit according index */
435 if (bus_id
!= 0 || unit_id
!= -1) {
436 error_report("index cannot be used with bus and unit");
439 bus_id
= drive_index_to_bus_id(type
, index
);
440 unit_id
= drive_index_to_unit_id(type
, index
);
443 /* if user doesn't specify a unit_id,
444 * try to find the first free
449 while (drive_get(type
, bus_id
, unit_id
) != NULL
) {
451 if (max_devs
&& unit_id
>= max_devs
) {
460 if (max_devs
&& unit_id
>= max_devs
) {
461 error_report("unit %d too big (max is %d)",
462 unit_id
, max_devs
- 1);
467 * catch multiple definitions
470 if (drive_get(type
, bus_id
, unit_id
) != NULL
) {
471 error_report("drive with bus=%d, unit=%d (index=%d) exists",
472 bus_id
, unit_id
, index
);
478 dinfo
= g_malloc0(sizeof(*dinfo
));
479 if ((buf
= qemu_opts_id(opts
)) != NULL
) {
480 dinfo
->id
= g_strdup(buf
);
482 /* no id supplied -> create one */
483 dinfo
->id
= g_malloc0(32);
484 if (type
== IF_IDE
|| type
== IF_SCSI
)
485 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
487 snprintf(dinfo
->id
, 32, "%s%i%s%i",
488 devname
, bus_id
, mediastr
, unit_id
);
490 snprintf(dinfo
->id
, 32, "%s%s%i",
491 devname
, mediastr
, unit_id
);
493 dinfo
->bdrv
= bdrv_new(dinfo
->id
);
494 dinfo
->devaddr
= devaddr
;
497 dinfo
->unit
= unit_id
;
501 strncpy(dinfo
->serial
, serial
, sizeof(dinfo
->serial
) - 1);
502 QTAILQ_INSERT_TAIL(&drives
, dinfo
, next
);
504 bdrv_set_on_error(dinfo
->bdrv
, on_read_error
, on_write_error
);
506 /* disk I/O throttling */
507 bdrv_set_io_limits(dinfo
->bdrv
, &io_limits
);
517 bdrv_set_geometry_hint(dinfo
->bdrv
, cyls
, heads
, secs
);
518 bdrv_set_translation_hint(dinfo
->bdrv
, translation
);
532 /* add virtio block device */
533 opts
= qemu_opts_create(qemu_find_opts("device"), NULL
, 0);
534 qemu_opt_set(opts
, "driver", "virtio-blk");
535 qemu_opt_set(opts
, "drive", dinfo
->id
);
537 qemu_opt_set(opts
, "addr", devaddr
);
542 if (!file
|| !*file
) {
546 /* always use cache=unsafe with snapshot */
547 bdrv_flags
&= ~BDRV_O_CACHE_MASK
;
548 bdrv_flags
|= (BDRV_O_SNAPSHOT
|BDRV_O_CACHE_WB
|BDRV_O_NO_FLUSH
);
552 bdrv_flags
|= BDRV_O_COPY_ON_READ
;
555 if (media
== MEDIA_CDROM
) {
556 /* CDROM is fine for any interface, don't check. */
558 } else if (ro
== 1) {
559 if (type
!= IF_SCSI
&& type
!= IF_VIRTIO
&& type
!= IF_FLOPPY
&& type
!= IF_NONE
) {
560 error_report("readonly not supported by this bus type");
565 bdrv_flags
|= ro
? 0 : BDRV_O_RDWR
;
567 ret
= bdrv_open(dinfo
->bdrv
, file
, bdrv_flags
, drv
);
569 error_report("could not open disk image %s: %s",
570 file
, strerror(-ret
));
574 if (bdrv_key_required(dinfo
->bdrv
))
579 bdrv_delete(dinfo
->bdrv
);
581 QTAILQ_REMOVE(&drives
, dinfo
, next
);
586 void do_commit(Monitor
*mon
, const QDict
*qdict
)
588 const char *device
= qdict_get_str(qdict
, "device");
589 BlockDriverState
*bs
;
591 if (!strcmp(device
, "all")) {
594 bs
= bdrv_find(device
);
596 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
603 int do_snapshot_blkdev(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
605 const char *device
= qdict_get_str(qdict
, "device");
606 const char *filename
= qdict_get_try_str(qdict
, "snapshot-file");
607 const char *format
= qdict_get_try_str(qdict
, "format");
608 BlockDriverState
*bs
;
609 BlockDriver
*drv
, *old_drv
, *proto_drv
;
612 char old_filename
[1024];
615 qerror_report(QERR_MISSING_PARAMETER
, "snapshot-file");
620 bs
= bdrv_find(device
);
622 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
627 pstrcpy(old_filename
, sizeof(old_filename
), bs
->filename
);
630 flags
= bs
->open_flags
;
636 drv
= bdrv_find_format(format
);
638 qerror_report(QERR_INVALID_BLOCK_FORMAT
, format
);
643 proto_drv
= bdrv_find_protocol(filename
);
645 qerror_report(QERR_INVALID_BLOCK_FORMAT
, format
);
650 ret
= bdrv_img_create(filename
, format
, bs
->filename
,
651 bs
->drv
->format_name
, NULL
, -1, flags
);
660 ret
= bdrv_open(bs
, filename
, flags
, drv
);
662 * If reopening the image file we just created fails, fall back
663 * and try to re-open the original image. If that fails too, we
664 * are in serious trouble.
667 ret
= bdrv_open(bs
, old_filename
, flags
, old_drv
);
669 qerror_report(QERR_OPEN_FILE_FAILED
, old_filename
);
671 qerror_report(QERR_OPEN_FILE_FAILED
, filename
);
682 static int eject_device(Monitor
*mon
, BlockDriverState
*bs
, int force
)
684 if (!bdrv_dev_has_removable_media(bs
)) {
685 qerror_report(QERR_DEVICE_NOT_REMOVABLE
, bdrv_get_device_name(bs
));
688 if (bdrv_dev_is_medium_locked(bs
) && !bdrv_dev_is_tray_open(bs
)) {
689 bdrv_dev_eject_request(bs
, force
);
691 qerror_report(QERR_DEVICE_LOCKED
, bdrv_get_device_name(bs
));
699 int do_eject(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
701 BlockDriverState
*bs
;
702 int force
= qdict_get_try_bool(qdict
, "force", 0);
703 const char *filename
= qdict_get_str(qdict
, "device");
705 bs
= bdrv_find(filename
);
707 qerror_report(QERR_DEVICE_NOT_FOUND
, filename
);
710 return eject_device(mon
, bs
, force
);
713 int do_block_set_passwd(Monitor
*mon
, const QDict
*qdict
,
716 BlockDriverState
*bs
;
719 bs
= bdrv_find(qdict_get_str(qdict
, "device"));
721 qerror_report(QERR_DEVICE_NOT_FOUND
, qdict_get_str(qdict
, "device"));
725 err
= bdrv_set_key(bs
, qdict_get_str(qdict
, "password"));
726 if (err
== -EINVAL
) {
727 qerror_report(QERR_DEVICE_NOT_ENCRYPTED
, bdrv_get_device_name(bs
));
729 } else if (err
< 0) {
730 qerror_report(QERR_INVALID_PASSWORD
);
737 int do_change_block(Monitor
*mon
, const char *device
,
738 const char *filename
, const char *fmt
)
740 BlockDriverState
*bs
;
741 BlockDriver
*drv
= NULL
;
744 bs
= bdrv_find(device
);
746 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
750 drv
= bdrv_find_whitelisted_format(fmt
);
752 qerror_report(QERR_INVALID_BLOCK_FORMAT
, fmt
);
756 if (eject_device(mon
, bs
, 0) < 0) {
759 bdrv_flags
= bdrv_is_read_only(bs
) ? 0 : BDRV_O_RDWR
;
760 bdrv_flags
|= bdrv_is_snapshot(bs
) ? BDRV_O_SNAPSHOT
: 0;
761 if (bdrv_open(bs
, filename
, bdrv_flags
, drv
) < 0) {
762 qerror_report(QERR_OPEN_FILE_FAILED
, filename
);
765 return monitor_read_bdrv_key_start(mon
, bs
, NULL
, NULL
);
768 /* throttling disk I/O limits */
769 int do_block_set_io_throttle(Monitor
*mon
,
770 const QDict
*qdict
, QObject
**ret_data
)
772 BlockIOLimit io_limits
;
773 const char *devname
= qdict_get_str(qdict
, "device");
774 BlockDriverState
*bs
;
776 io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]
777 = qdict_get_try_int(qdict
, "bps", -1);
778 io_limits
.bps
[BLOCK_IO_LIMIT_READ
]
779 = qdict_get_try_int(qdict
, "bps_rd", -1);
780 io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
]
781 = qdict_get_try_int(qdict
, "bps_wr", -1);
782 io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]
783 = qdict_get_try_int(qdict
, "iops", -1);
784 io_limits
.iops
[BLOCK_IO_LIMIT_READ
]
785 = qdict_get_try_int(qdict
, "iops_rd", -1);
786 io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
]
787 = qdict_get_try_int(qdict
, "iops_wr", -1);
789 bs
= bdrv_find(devname
);
791 qerror_report(QERR_DEVICE_NOT_FOUND
, devname
);
795 if ((io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
] == -1)
796 || (io_limits
.bps
[BLOCK_IO_LIMIT_READ
] == -1)
797 || (io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
] == -1)
798 || (io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
] == -1)
799 || (io_limits
.iops
[BLOCK_IO_LIMIT_READ
] == -1)
800 || (io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
] == -1)) {
801 qerror_report(QERR_MISSING_PARAMETER
,
802 "bps/bps_rd/bps_wr/iops/iops_rd/iops_wr");
806 if (!do_check_io_limits(&io_limits
)) {
807 qerror_report(QERR_INVALID_PARAMETER_COMBINATION
);
811 bs
->io_limits
= io_limits
;
812 bs
->slice_time
= BLOCK_IO_SLICE_TIME
;
814 if (!bs
->io_limits_enabled
&& bdrv_io_limits_enabled(bs
)) {
815 bdrv_io_limits_enable(bs
);
816 } else if (bs
->io_limits_enabled
&& !bdrv_io_limits_enabled(bs
)) {
817 bdrv_io_limits_disable(bs
);
819 if (bs
->block_timer
) {
820 qemu_mod_timer(bs
->block_timer
, qemu_get_clock_ns(vm_clock
));
827 int do_drive_del(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
829 const char *id
= qdict_get_str(qdict
, "id");
830 BlockDriverState
*bs
;
834 qerror_report(QERR_DEVICE_NOT_FOUND
, id
);
837 if (bdrv_in_use(bs
)) {
838 qerror_report(QERR_DEVICE_IN_USE
, id
);
842 /* quiesce block driver; prevent further io */
847 /* if we have a device attached to this BlockDriverState
848 * then we need to make the drive anonymous until the device
849 * can be removed. If this is a drive with no device backing
850 * then we can just get rid of the block driver state right here.
852 if (bdrv_get_attached_dev(bs
)) {
855 drive_uninit(drive_get_by_blockdev(bs
));
862 * XXX: replace the QERR_UNDEFINED_ERROR errors with real values once the
863 * existing QERR_ macro mess is cleaned up. A good example for better
864 * error reports can be found in the qemu-img resize code.
866 int do_block_resize(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
868 const char *device
= qdict_get_str(qdict
, "device");
869 int64_t size
= qdict_get_int(qdict
, "size");
870 BlockDriverState
*bs
;
872 bs
= bdrv_find(device
);
874 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
879 qerror_report(QERR_UNDEFINED_ERROR
);
883 if (bdrv_truncate(bs
, size
)) {
884 qerror_report(QERR_UNDEFINED_ERROR
);