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"
18 #include "block_int.h"
20 static QTAILQ_HEAD(drivelist
, DriveInfo
) drives
= QTAILQ_HEAD_INITIALIZER(drives
);
22 static const char *const if_name
[IF_COUNT
] = {
26 [IF_FLOPPY
] = "floppy",
27 [IF_PFLASH
] = "pflash",
30 [IF_VIRTIO
] = "virtio",
34 static const int if_max_devs
[IF_COUNT
] = {
36 * Do not change these numbers! They govern how drive option
37 * index maps to unit and bus. That mapping is ABI.
39 * All controllers used to imlement if=T drives need to support
40 * if_max_devs[T] units, for any T with if_max_devs[T] != 0.
41 * Otherwise, some index values map to "impossible" bus, unit
44 * For instance, if you change [IF_SCSI] to 255, -drive
45 * if=scsi,index=12 no longer means bus=1,unit=5, but
46 * bus=0,unit=12. With an lsi53c895a controller (7 units max),
47 * the drive can't be set up. Regression.
54 * We automatically delete the drive when a device using it gets
55 * unplugged. Questionable feature, but we can't just drop it.
56 * Device models call blockdev_mark_auto_del() to schedule the
57 * automatic deletion, and generic qdev code calls blockdev_auto_del()
58 * when deletion is actually safe.
60 void blockdev_mark_auto_del(BlockDriverState
*bs
)
62 DriveInfo
*dinfo
= drive_get_by_blockdev(bs
);
69 void blockdev_auto_del(BlockDriverState
*bs
)
71 DriveInfo
*dinfo
= drive_get_by_blockdev(bs
);
73 if (dinfo
&& dinfo
->auto_del
) {
78 static int drive_index_to_bus_id(BlockInterfaceType type
, int index
)
80 int max_devs
= if_max_devs
[type
];
81 return max_devs
? index
/ max_devs
: 0;
84 static int drive_index_to_unit_id(BlockInterfaceType type
, int index
)
86 int max_devs
= if_max_devs
[type
];
87 return max_devs
? index
% max_devs
: index
;
90 QemuOpts
*drive_def(const char *optstr
)
92 return qemu_opts_parse(qemu_find_opts("drive"), optstr
, 0);
95 QemuOpts
*drive_add(BlockInterfaceType type
, int index
, const char *file
,
101 opts
= drive_def(optstr
);
105 if (type
!= IF_DEFAULT
) {
106 qemu_opt_set(opts
, "if", if_name
[type
]);
109 snprintf(buf
, sizeof(buf
), "%d", index
);
110 qemu_opt_set(opts
, "index", buf
);
113 qemu_opt_set(opts
, "file", file
);
117 DriveInfo
*drive_get(BlockInterfaceType type
, int bus
, int unit
)
121 /* seek interface, bus and unit */
123 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
124 if (dinfo
->type
== type
&&
133 DriveInfo
*drive_get_by_index(BlockInterfaceType type
, int index
)
135 return drive_get(type
,
136 drive_index_to_bus_id(type
, index
),
137 drive_index_to_unit_id(type
, index
));
140 int drive_get_max_bus(BlockInterfaceType type
)
146 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
147 if(dinfo
->type
== type
&&
148 dinfo
->bus
> max_bus
)
149 max_bus
= dinfo
->bus
;
154 /* Get a block device. This should only be used for single-drive devices
155 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the
157 DriveInfo
*drive_get_next(BlockInterfaceType type
)
159 static int next_block_unit
[IF_COUNT
];
161 return drive_get(type
, 0, next_block_unit
[type
]++);
164 DriveInfo
*drive_get_by_blockdev(BlockDriverState
*bs
)
168 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
169 if (dinfo
->bdrv
== bs
) {
176 static void bdrv_format_print(void *opaque
, const char *name
)
178 error_printf(" %s", name
);
181 static void drive_uninit(DriveInfo
*dinfo
)
183 qemu_opts_del(dinfo
->opts
);
184 bdrv_delete(dinfo
->bdrv
);
185 qemu_free(dinfo
->id
);
186 QTAILQ_REMOVE(&drives
, dinfo
, next
);
190 void drive_put_ref(DriveInfo
*dinfo
)
192 assert(dinfo
->refcount
);
193 if (--dinfo
->refcount
== 0) {
198 void drive_get_ref(DriveInfo
*dinfo
)
203 static int parse_block_error_action(const char *buf
, int is_read
)
205 if (!strcmp(buf
, "ignore")) {
206 return BLOCK_ERR_IGNORE
;
207 } else if (!is_read
&& !strcmp(buf
, "enospc")) {
208 return BLOCK_ERR_STOP_ENOSPC
;
209 } else if (!strcmp(buf
, "stop")) {
210 return BLOCK_ERR_STOP_ANY
;
211 } else if (!strcmp(buf
, "report")) {
212 return BLOCK_ERR_REPORT
;
214 error_report("'%s' invalid %s error action",
215 buf
, is_read
? "read" : "write");
220 DriveInfo
*drive_init(QemuOpts
*opts
, int default_to_scsi
)
223 const char *file
= NULL
;
226 const char *mediastr
= "";
227 BlockInterfaceType type
;
228 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
230 int cyls
, heads
, secs
, translation
;
231 BlockDriver
*drv
= NULL
;
236 int on_read_error
, on_write_error
;
242 translation
= BIOS_ATA_TRANSLATION_AUTO
;
245 /* extract parameters */
246 bus_id
= qemu_opt_get_number(opts
, "bus", 0);
247 unit_id
= qemu_opt_get_number(opts
, "unit", -1);
248 index
= qemu_opt_get_number(opts
, "index", -1);
250 cyls
= qemu_opt_get_number(opts
, "cyls", 0);
251 heads
= qemu_opt_get_number(opts
, "heads", 0);
252 secs
= qemu_opt_get_number(opts
, "secs", 0);
254 snapshot
= qemu_opt_get_bool(opts
, "snapshot", 0);
255 ro
= qemu_opt_get_bool(opts
, "readonly", 0);
257 file
= qemu_opt_get(opts
, "file");
258 serial
= qemu_opt_get(opts
, "serial");
260 if ((buf
= qemu_opt_get(opts
, "if")) != NULL
) {
261 pstrcpy(devname
, sizeof(devname
), buf
);
262 for (type
= 0; type
< IF_COUNT
&& strcmp(buf
, if_name
[type
]); type
++)
264 if (type
== IF_COUNT
) {
265 error_report("unsupported bus type '%s'", buf
);
269 type
= default_to_scsi
? IF_SCSI
: IF_IDE
;
270 pstrcpy(devname
, sizeof(devname
), if_name
[type
]);
273 max_devs
= if_max_devs
[type
];
275 if (cyls
|| heads
|| secs
) {
276 if (cyls
< 1 || (type
== IF_IDE
&& cyls
> 16383)) {
277 error_report("invalid physical cyls number");
280 if (heads
< 1 || (type
== IF_IDE
&& heads
> 16)) {
281 error_report("invalid physical heads number");
284 if (secs
< 1 || (type
== IF_IDE
&& secs
> 63)) {
285 error_report("invalid physical secs number");
290 if ((buf
= qemu_opt_get(opts
, "trans")) != NULL
) {
292 error_report("'%s' trans must be used with cyls, heads and secs",
296 if (!strcmp(buf
, "none"))
297 translation
= BIOS_ATA_TRANSLATION_NONE
;
298 else if (!strcmp(buf
, "lba"))
299 translation
= BIOS_ATA_TRANSLATION_LBA
;
300 else if (!strcmp(buf
, "auto"))
301 translation
= BIOS_ATA_TRANSLATION_AUTO
;
303 error_report("'%s' invalid translation type", buf
);
308 if ((buf
= qemu_opt_get(opts
, "media")) != NULL
) {
309 if (!strcmp(buf
, "disk")) {
311 } else if (!strcmp(buf
, "cdrom")) {
312 if (cyls
|| secs
|| heads
) {
313 error_report("CHS can't be set with media=%s", buf
);
318 error_report("'%s' invalid media", buf
);
323 if ((buf
= qemu_opt_get(opts
, "cache")) != NULL
) {
324 if (!strcmp(buf
, "off") || !strcmp(buf
, "none")) {
325 bdrv_flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
326 } else if (!strcmp(buf
, "writeback")) {
327 bdrv_flags
|= BDRV_O_CACHE_WB
;
328 } else if (!strcmp(buf
, "unsafe")) {
329 bdrv_flags
|= BDRV_O_CACHE_WB
;
330 bdrv_flags
|= BDRV_O_NO_FLUSH
;
331 } else if (!strcmp(buf
, "writethrough")) {
332 /* this is the default */
334 error_report("invalid cache option");
339 #ifdef CONFIG_LINUX_AIO
340 if ((buf
= qemu_opt_get(opts
, "aio")) != NULL
) {
341 if (!strcmp(buf
, "native")) {
342 bdrv_flags
|= BDRV_O_NATIVE_AIO
;
343 } else if (!strcmp(buf
, "threads")) {
344 /* this is the default */
346 error_report("invalid aio option");
352 if ((buf
= qemu_opt_get(opts
, "format")) != NULL
) {
353 if (strcmp(buf
, "?") == 0) {
354 error_printf("Supported formats:");
355 bdrv_iterate_format(bdrv_format_print
, NULL
);
359 drv
= bdrv_find_whitelisted_format(buf
);
361 error_report("'%s' invalid format", buf
);
366 on_write_error
= BLOCK_ERR_STOP_ENOSPC
;
367 if ((buf
= qemu_opt_get(opts
, "werror")) != NULL
) {
368 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
&& type
!= IF_NONE
) {
369 error_report("werror is not supported by this bus type");
373 on_write_error
= parse_block_error_action(buf
, 0);
374 if (on_write_error
< 0) {
379 on_read_error
= BLOCK_ERR_REPORT
;
380 if ((buf
= qemu_opt_get(opts
, "rerror")) != NULL
) {
381 if (type
!= IF_IDE
&& type
!= IF_VIRTIO
&& type
!= IF_SCSI
&& type
!= IF_NONE
) {
382 error_report("rerror is not supported by this bus type");
386 on_read_error
= parse_block_error_action(buf
, 1);
387 if (on_read_error
< 0) {
392 if ((devaddr
= qemu_opt_get(opts
, "addr")) != NULL
) {
393 if (type
!= IF_VIRTIO
) {
394 error_report("addr is not supported by this bus type");
399 /* compute bus and unit according index */
402 if (bus_id
!= 0 || unit_id
!= -1) {
403 error_report("index cannot be used with bus and unit");
406 bus_id
= drive_index_to_bus_id(type
, index
);
407 unit_id
= drive_index_to_unit_id(type
, index
);
410 /* if user doesn't specify a unit_id,
411 * try to find the first free
416 while (drive_get(type
, bus_id
, unit_id
) != NULL
) {
418 if (max_devs
&& unit_id
>= max_devs
) {
427 if (max_devs
&& unit_id
>= max_devs
) {
428 error_report("unit %d too big (max is %d)",
429 unit_id
, max_devs
- 1);
434 * catch multiple definitions
437 if (drive_get(type
, bus_id
, unit_id
) != NULL
) {
438 error_report("drive with bus=%d, unit=%d (index=%d) exists",
439 bus_id
, unit_id
, index
);
445 dinfo
= qemu_mallocz(sizeof(*dinfo
));
446 if ((buf
= qemu_opts_id(opts
)) != NULL
) {
447 dinfo
->id
= qemu_strdup(buf
);
449 /* no id supplied -> create one */
450 dinfo
->id
= qemu_mallocz(32);
451 if (type
== IF_IDE
|| type
== IF_SCSI
)
452 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
454 snprintf(dinfo
->id
, 32, "%s%i%s%i",
455 devname
, bus_id
, mediastr
, unit_id
);
457 snprintf(dinfo
->id
, 32, "%s%s%i",
458 devname
, mediastr
, unit_id
);
460 dinfo
->bdrv
= bdrv_new(dinfo
->id
);
461 dinfo
->devaddr
= devaddr
;
464 dinfo
->unit
= unit_id
;
468 strncpy(dinfo
->serial
, serial
, sizeof(dinfo
->serial
) - 1);
469 QTAILQ_INSERT_TAIL(&drives
, dinfo
, next
);
471 bdrv_set_on_error(dinfo
->bdrv
, on_read_error
, on_write_error
);
481 bdrv_set_geometry_hint(dinfo
->bdrv
, cyls
, heads
, secs
);
482 bdrv_set_translation_hint(dinfo
->bdrv
, translation
);
486 bdrv_set_removable(dinfo
->bdrv
, 1);
492 /* FIXME: This isn't really a floppy, but it's a reasonable
495 bdrv_set_removable(dinfo
->bdrv
, 1);
501 /* add virtio block device */
502 opts
= qemu_opts_create(qemu_find_opts("device"), NULL
, 0);
503 qemu_opt_set(opts
, "driver", "virtio-blk");
504 qemu_opt_set(opts
, "drive", dinfo
->id
);
506 qemu_opt_set(opts
, "addr", devaddr
);
511 if (!file
|| !*file
) {
515 /* always use cache=unsafe with snapshot */
516 bdrv_flags
&= ~BDRV_O_CACHE_MASK
;
517 bdrv_flags
|= (BDRV_O_SNAPSHOT
|BDRV_O_CACHE_WB
|BDRV_O_NO_FLUSH
);
520 if (media
== MEDIA_CDROM
) {
521 /* CDROM is fine for any interface, don't check. */
523 } else if (ro
== 1) {
524 if (type
!= IF_SCSI
&& type
!= IF_VIRTIO
&& type
!= IF_FLOPPY
&& type
!= IF_NONE
) {
525 error_report("readonly not supported by this bus type");
530 bdrv_flags
|= ro
? 0 : BDRV_O_RDWR
;
532 ret
= bdrv_open(dinfo
->bdrv
, file
, bdrv_flags
, drv
);
534 error_report("could not open disk image %s: %s",
535 file
, strerror(-ret
));
539 if (bdrv_key_required(dinfo
->bdrv
))
544 bdrv_delete(dinfo
->bdrv
);
545 qemu_free(dinfo
->id
);
546 QTAILQ_REMOVE(&drives
, dinfo
, next
);
551 void do_commit(Monitor
*mon
, const QDict
*qdict
)
553 const char *device
= qdict_get_str(qdict
, "device");
554 BlockDriverState
*bs
;
556 if (!strcmp(device
, "all")) {
559 bs
= bdrv_find(device
);
561 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
568 int do_snapshot_blkdev(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
570 const char *device
= qdict_get_str(qdict
, "device");
571 const char *filename
= qdict_get_try_str(qdict
, "snapshot_file");
572 const char *format
= qdict_get_try_str(qdict
, "format");
573 BlockDriverState
*bs
;
574 BlockDriver
*drv
, *old_drv
, *proto_drv
;
577 char old_filename
[1024];
580 qerror_report(QERR_MISSING_PARAMETER
, "snapshot_file");
585 bs
= bdrv_find(device
);
587 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
592 pstrcpy(old_filename
, sizeof(old_filename
), bs
->filename
);
595 flags
= bs
->open_flags
;
601 drv
= bdrv_find_format(format
);
603 qerror_report(QERR_INVALID_BLOCK_FORMAT
, format
);
608 proto_drv
= bdrv_find_protocol(filename
);
610 qerror_report(QERR_INVALID_BLOCK_FORMAT
, format
);
615 ret
= bdrv_img_create(filename
, format
, bs
->filename
,
616 bs
->drv
->format_name
, NULL
, -1, flags
);
625 ret
= bdrv_open(bs
, filename
, flags
, drv
);
627 * If reopening the image file we just created fails, fall back
628 * and try to re-open the original image. If that fails too, we
629 * are in serious trouble.
632 ret
= bdrv_open(bs
, old_filename
, flags
, old_drv
);
634 qerror_report(QERR_OPEN_FILE_FAILED
, old_filename
);
636 qerror_report(QERR_OPEN_FILE_FAILED
, filename
);
647 static int eject_device(Monitor
*mon
, BlockDriverState
*bs
, int force
)
650 if (!bdrv_is_removable(bs
)) {
651 qerror_report(QERR_DEVICE_NOT_REMOVABLE
,
652 bdrv_get_device_name(bs
));
655 if (bdrv_is_locked(bs
)) {
656 qerror_report(QERR_DEVICE_LOCKED
, bdrv_get_device_name(bs
));
664 int do_eject(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
666 BlockDriverState
*bs
;
667 int force
= qdict_get_try_bool(qdict
, "force", 0);
668 const char *filename
= qdict_get_str(qdict
, "device");
670 bs
= bdrv_find(filename
);
672 qerror_report(QERR_DEVICE_NOT_FOUND
, filename
);
675 return eject_device(mon
, bs
, force
);
678 int do_block_set_passwd(Monitor
*mon
, const QDict
*qdict
,
681 BlockDriverState
*bs
;
684 bs
= bdrv_find(qdict_get_str(qdict
, "device"));
686 qerror_report(QERR_DEVICE_NOT_FOUND
, qdict_get_str(qdict
, "device"));
690 err
= bdrv_set_key(bs
, qdict_get_str(qdict
, "password"));
691 if (err
== -EINVAL
) {
692 qerror_report(QERR_DEVICE_NOT_ENCRYPTED
, bdrv_get_device_name(bs
));
694 } else if (err
< 0) {
695 qerror_report(QERR_INVALID_PASSWORD
);
702 int do_change_block(Monitor
*mon
, const char *device
,
703 const char *filename
, const char *fmt
)
705 BlockDriverState
*bs
;
706 BlockDriver
*drv
= NULL
;
709 bs
= bdrv_find(device
);
711 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
715 drv
= bdrv_find_whitelisted_format(fmt
);
717 qerror_report(QERR_INVALID_BLOCK_FORMAT
, fmt
);
721 if (eject_device(mon
, bs
, 0) < 0) {
724 bdrv_flags
= bdrv_is_read_only(bs
) ? 0 : BDRV_O_RDWR
;
725 bdrv_flags
|= bdrv_is_snapshot(bs
) ? BDRV_O_SNAPSHOT
: 0;
726 if (bdrv_open(bs
, filename
, bdrv_flags
, drv
) < 0) {
727 qerror_report(QERR_OPEN_FILE_FAILED
, filename
);
730 return monitor_read_bdrv_key_start(mon
, bs
, NULL
, NULL
);
733 int do_drive_del(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
735 const char *id
= qdict_get_str(qdict
, "id");
736 BlockDriverState
*bs
;
740 qerror_report(QERR_DEVICE_NOT_FOUND
, id
);
743 if (bdrv_in_use(bs
)) {
744 qerror_report(QERR_DEVICE_IN_USE
, id
);
748 /* quiesce block driver; prevent further io */
753 /* if we have a device associated with this BlockDriverState (bs->peer)
754 * then we need to make the drive anonymous until the device
755 * can be removed. If this is a drive with no device backing
756 * then we can just get rid of the block driver state right here.
761 drive_uninit(drive_get_by_blockdev(bs
));
768 * XXX: replace the QERR_UNDEFINED_ERROR errors with real values once the
769 * existing QERR_ macro mess is cleaned up. A good example for better
770 * error reports can be found in the qemu-img resize code.
772 int do_block_resize(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
774 const char *device
= qdict_get_str(qdict
, "device");
775 int64_t size
= qdict_get_int(qdict
, "size");
776 BlockDriverState
*bs
;
778 bs
= bdrv_find(device
);
780 qerror_report(QERR_DEVICE_NOT_FOUND
, device
);
785 qerror_report(QERR_UNDEFINED_ERROR
);
789 if (bdrv_truncate(bs
, size
)) {
790 qerror_report(QERR_UNDEFINED_ERROR
);