2007-11-11 03:51:17 +01:00
|
|
|
#ifndef BLOCK_H
|
|
|
|
#define BLOCK_H
|
|
|
|
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/aio.h"
|
2009-01-22 17:59:24 +01:00
|
|
|
#include "qemu-common.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/option.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/coroutine.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qobject.h"
|
2012-09-28 17:22:47 +02:00
|
|
|
#include "qapi-types.h"
|
2008-09-22 21:17:18 +02:00
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
/* block.c */
|
|
|
|
typedef struct BlockDriver BlockDriver;
|
2012-09-28 17:22:47 +02:00
|
|
|
typedef struct BlockJob BlockJob;
|
2007-11-11 03:51:17 +01:00
|
|
|
|
|
|
|
typedef struct BlockDriverInfo {
|
|
|
|
/* in bytes, 0 if irrelevant */
|
|
|
|
int cluster_size;
|
|
|
|
/* offset at which the VM state can be saved (0 if not possible) */
|
|
|
|
int64_t vm_state_offset;
|
2012-03-15 13:13:33 +01:00
|
|
|
bool is_dirty;
|
2007-11-11 03:51:17 +01:00
|
|
|
} BlockDriverInfo;
|
|
|
|
|
2012-03-15 13:13:31 +01:00
|
|
|
typedef struct BlockFragInfo {
|
|
|
|
uint64_t allocated_clusters;
|
|
|
|
uint64_t total_clusters;
|
|
|
|
uint64_t fragmented_clusters;
|
|
|
|
} BlockFragInfo;
|
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
typedef struct QEMUSnapshotInfo {
|
|
|
|
char id_str[128]; /* unique snapshot id */
|
|
|
|
/* the following fields are informative. They are not needed for
|
|
|
|
the consistency of the snapshot */
|
2011-12-10 00:19:46 +01:00
|
|
|
char name[256]; /* user chosen name */
|
2011-11-16 11:35:54 +01:00
|
|
|
uint64_t vm_state_size; /* VM state info size */
|
2007-11-11 03:51:17 +01:00
|
|
|
uint32_t date_sec; /* UTC date of the snapshot */
|
|
|
|
uint32_t date_nsec;
|
|
|
|
uint64_t vm_clock_nsec; /* VM clock relative to boot */
|
|
|
|
} QEMUSnapshotInfo;
|
|
|
|
|
2011-08-03 15:07:42 +02:00
|
|
|
/* Callbacks for block device models */
|
2011-08-03 15:07:41 +02:00
|
|
|
typedef struct BlockDevOps {
|
2011-08-03 15:07:42 +02:00
|
|
|
/*
|
|
|
|
* Runs when virtual media changed (monitor commands eject, change)
|
2011-09-06 18:58:59 +02:00
|
|
|
* Argument load is true on load and false on eject.
|
2011-08-03 15:07:42 +02:00
|
|
|
* Beware: doesn't run when a host device's physical media
|
|
|
|
* changes. Sure would be useful if it did.
|
block: Clean up remaining users of "removable"
BlockDriverState member removable is a confused mess. It is true when
an ide-cd, scsi-cd or floppy qdev is attached, or when the
BlockDriverState was created with -drive if={floppy,sd} or -drive
if={ide,scsi,xen,none},media=cdrom ("created removable"), except when
an ide-hd, scsi-hd, scsi-generic or virtio-blk qdev is attached.
Three users remain:
1. eject_device(), via bdrv_is_removable() uses it to determine
whether a block device can eject media.
2. bdrv_info() is monitor command "info block". QMP documentation
says "true if the device is removable, false otherwise". From the
monitor user's point of view, the only sensible interpretation of
"is removable" is "can eject media with monitor commands eject and
change".
A block device can eject media unless a device is attached that
doesn't support it. Switch the two users over to new
bdrv_dev_has_removable_media() that returns exactly that.
3. bdrv_getlength() uses to suppress its length cache when media can
change (see commit 46a4e4e6). Media change is either monitor
command change (updates the length cache), monitor command eject
(doesn't update the length cache, easily fixable), or physical
media change (invalidates length cache, not so easily fixable).
I'm refraining from improving anything here, because this series is
long enough already. Instead, I simply switch it over to
bdrv_dev_has_removable_media() as well.
This changes the behavior of the length cache and of monitor commands
eject and change in two cases:
a. drive not created removable, no device attached
The commit makes the drive removable, and defeats the length cache.
Example: -drive if=none
b. drive created removable, but the attached drive is non-removable,
and doesn't call bdrv_set_removable(..., 0) (most devices don't)
The commit makes the drive non-removable, and enables the length
cache.
Example: -drive if=xen,media=cdrom -M xenpv
The other non-removable devices that don't call
bdrv_set_removable() can't currently use a drive created removable,
either because they aren't qdevified, or because they lack a drive
property. Won't stay that way.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2011-09-06 18:58:51 +02:00
|
|
|
* Device models with removable media must implement this callback.
|
2011-08-03 15:07:42 +02:00
|
|
|
*/
|
2011-09-06 18:58:59 +02:00
|
|
|
void (*change_media_cb)(void *opaque, bool load);
|
2011-11-07 17:50:13 +01:00
|
|
|
/*
|
|
|
|
* Runs when an eject request is issued from the monitor, the tray
|
|
|
|
* is closed, and the medium is locked.
|
|
|
|
* Device models that do not implement is_medium_locked will not need
|
|
|
|
* this callback. Device models that can lock the medium or tray might
|
|
|
|
* want to implement the callback and unlock the tray when "force" is
|
|
|
|
* true, even if they do not support eject requests.
|
|
|
|
*/
|
|
|
|
void (*eject_request_cb)(void *opaque, bool force);
|
2011-09-06 18:58:53 +02:00
|
|
|
/*
|
|
|
|
* Is the virtual tray open?
|
|
|
|
* Device models implement this only when the device has a tray.
|
|
|
|
*/
|
|
|
|
bool (*is_tray_open)(void *opaque);
|
2011-09-06 18:58:46 +02:00
|
|
|
/*
|
|
|
|
* Is the virtual medium locked into the device?
|
|
|
|
* Device models implement this only when device has such a lock.
|
|
|
|
*/
|
|
|
|
bool (*is_medium_locked)(void *opaque);
|
2011-08-03 15:07:42 +02:00
|
|
|
/*
|
|
|
|
* Runs when the size changed (e.g. monitor command block_resize)
|
|
|
|
*/
|
|
|
|
void (*resize_cb)(void *opaque);
|
2011-08-03 15:07:41 +02:00
|
|
|
} BlockDevOps;
|
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
#define BDRV_O_RDWR 0x0002
|
|
|
|
#define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */
|
2008-10-14 16:42:54 +02:00
|
|
|
#define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */
|
|
|
|
#define BDRV_O_CACHE_WB 0x0040 /* use write-back caching */
|
2009-08-20 16:58:35 +02:00
|
|
|
#define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the thread pool */
|
2010-01-12 12:55:16 +01:00
|
|
|
#define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */
|
2010-05-26 17:51:49 +02:00
|
|
|
#define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */
|
2011-11-28 17:08:47 +01:00
|
|
|
#define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */
|
2012-03-23 08:36:48 +01:00
|
|
|
#define BDRV_O_INCOMING 0x0800 /* consistency hint for incoming migration */
|
2012-08-09 14:05:56 +02:00
|
|
|
#define BDRV_O_CHECK 0x1000 /* open solely for consistency check */
|
block: correctly set the keep_read_only flag
I believe the bs->keep_read_only flag is supposed to reflect
the initial open state of the device. If the device is initially
opened R/O, then commit operations, or reopen operations changing
to R/W, are prohibited.
Currently, the keep_read_only flag is only accurate for the active
layer, and its backing file. Subsequent images end up always having
the keep_read_only flag set.
For instance, what happens now:
[ base ] kro = 1, ro = 1
|
v
[ snap-1 ] kro = 1, ro = 1
|
v
[ snap-2 ] kro = 0, ro = 1
|
v
[ active ] kro = 0, ro = 0
What we want:
[ base ] kro = 0, ro = 1
|
v
[ snap-1 ] kro = 0, ro = 1
|
v
[ snap-2 ] kro = 0, ro = 1
|
v
[ active ] kro = 0, ro = 0
Signed-off-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-20 21:13:17 +02:00
|
|
|
#define BDRV_O_ALLOW_RDWR 0x2000 /* allow reopen to change from r/o to r/w */
|
2008-10-14 16:42:54 +02:00
|
|
|
|
2010-08-31 15:08:03 +02:00
|
|
|
#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
|
2007-11-11 03:51:17 +01:00
|
|
|
|
2009-11-30 18:21:19 +01:00
|
|
|
#define BDRV_SECTOR_BITS 9
|
2010-05-27 15:46:55 +02:00
|
|
|
#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
|
2010-05-01 08:23:32 +02:00
|
|
|
#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
|
2009-11-30 18:21:19 +01:00
|
|
|
|
2010-02-03 15:41:01 +01:00
|
|
|
typedef enum {
|
|
|
|
BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
|
2012-09-28 17:22:54 +02:00
|
|
|
} BlockErrorAction;
|
2010-02-03 15:41:01 +01:00
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
|
|
|
|
|
|
|
|
typedef struct BDRVReopenState {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
int flags;
|
|
|
|
void *opaque;
|
|
|
|
} BDRVReopenState;
|
|
|
|
|
|
|
|
|
2011-09-26 22:43:50 +02:00
|
|
|
void bdrv_iostatus_enable(BlockDriverState *bs);
|
|
|
|
void bdrv_iostatus_reset(BlockDriverState *bs);
|
|
|
|
void bdrv_iostatus_disable(BlockDriverState *bs);
|
|
|
|
bool bdrv_iostatus_is_enabled(const BlockDriverState *bs);
|
|
|
|
void bdrv_iostatus_set_err(BlockDriverState *bs, int error);
|
2009-12-10 20:16:06 +01:00
|
|
|
void bdrv_info_print(Monitor *mon, const QObject *data);
|
|
|
|
void bdrv_info(Monitor *mon, QObject **ret_data);
|
2009-12-10 20:16:07 +01:00
|
|
|
void bdrv_stats_print(Monitor *mon, const QObject *data);
|
|
|
|
void bdrv_info_stats(Monitor *mon, QObject **ret_data);
|
2007-11-11 03:51:17 +01:00
|
|
|
|
2011-11-03 09:57:25 +01:00
|
|
|
/* disk I/O throttling */
|
|
|
|
void bdrv_io_limits_enable(BlockDriverState *bs);
|
2011-11-08 06:00:14 +01:00
|
|
|
void bdrv_io_limits_disable(BlockDriverState *bs);
|
2011-11-03 09:57:25 +01:00
|
|
|
bool bdrv_io_limits_enabled(BlockDriverState *bs);
|
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_init(void);
|
2009-10-27 18:41:44 +01:00
|
|
|
void bdrv_init_with_whitelist(void);
|
2010-05-26 04:35:36 +02:00
|
|
|
BlockDriver *bdrv_find_protocol(const char *filename);
|
2007-11-11 03:51:17 +01:00
|
|
|
BlockDriver *bdrv_find_format(const char *format_name);
|
2009-10-27 18:41:44 +01:00
|
|
|
BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
|
2009-05-18 16:42:10 +02:00
|
|
|
int bdrv_create(BlockDriver *drv, const char* filename,
|
|
|
|
QEMUOptionParameter *options);
|
2010-04-07 22:30:24 +02:00
|
|
|
int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
|
2007-11-11 03:51:17 +01:00
|
|
|
BlockDriverState *bdrv_new(const char *device_name);
|
Do not delete BlockDriverState when deleting the drive
When removing a drive from the host-side via drive_del we currently have
the following path:
drive_del
qemu_aio_flush()
bdrv_close() // zaps bs->drv, which makes any subsequent I/O get
// dropped. Works as designed
drive_uninit()
bdrv_delete() // frees the bs. Since the device is still connected to
// bs, any subsequent I/O is a use-after-free.
The value of bs->drv becomes unpredictable on free. As long as it
remains null, I/O still gets dropped, however it could become non-null
at any point after the free resulting SEGVs or other QEMU state
corruption.
To resolve this issue as simply as possible, we can chose to not
actually delete the BlockDriverState pointer. Since bdrv_close()
handles setting the drv pointer to NULL, we just need to remove the
BlockDriverState from the QLIST that is used to enumerate the block
devices. This is currently handled within bdrv_delete, so move this
into its own function, bdrv_make_anon().
The result is that we can now invoke drive_del, this closes the file
descriptors and sets BlockDriverState->drv to NULL which prevents futher
IO to the device, and since we do not free BlockDriverState, we don't
have to worry about the copy retained in the block devices.
We also don't attempt to remove the qdev property since we are no longer
deleting the BlockDriverState on drives with associated drives. This
also allows for removing Drives with no devices associated either.
Reported-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Ryan Harper <ryanh@us.ibm.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2011-03-30 03:51:47 +02:00
|
|
|
void bdrv_make_anon(BlockDriverState *bs);
|
2012-06-14 16:55:02 +02:00
|
|
|
void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old);
|
2012-02-28 21:54:06 +01:00
|
|
|
void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_delete(BlockDriverState *bs);
|
2011-08-04 13:26:51 +02:00
|
|
|
int bdrv_parse_cache_flags(const char *mode, int *flags);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
|
2012-10-18 16:49:17 +02:00
|
|
|
int bdrv_open_backing_file(BlockDriverState *bs);
|
2010-03-31 14:40:27 +02:00
|
|
|
int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
|
|
|
|
BlockDriver *drv);
|
2012-09-20 21:13:19 +02:00
|
|
|
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
|
|
|
|
BlockDriverState *bs, int flags);
|
|
|
|
int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
|
|
|
|
int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
|
|
|
|
int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
|
|
|
|
BlockReopenQueue *queue, Error **errp);
|
|
|
|
void bdrv_reopen_commit(BDRVReopenState *reopen_state);
|
|
|
|
void bdrv_reopen_abort(BDRVReopenState *reopen_state);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_close(BlockDriverState *bs);
|
2012-08-23 11:20:36 +02:00
|
|
|
void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify);
|
2011-08-03 15:07:40 +02:00
|
|
|
int bdrv_attach_dev(BlockDriverState *bs, void *dev);
|
|
|
|
void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev);
|
|
|
|
void bdrv_detach_dev(BlockDriverState *bs, void *dev);
|
|
|
|
void *bdrv_get_attached_dev(BlockDriverState *bs);
|
2011-08-03 15:07:41 +02:00
|
|
|
void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
|
|
|
|
void *opaque);
|
2011-11-07 17:50:13 +01:00
|
|
|
void bdrv_dev_eject_request(BlockDriverState *bs, bool force);
|
block: Clean up remaining users of "removable"
BlockDriverState member removable is a confused mess. It is true when
an ide-cd, scsi-cd or floppy qdev is attached, or when the
BlockDriverState was created with -drive if={floppy,sd} or -drive
if={ide,scsi,xen,none},media=cdrom ("created removable"), except when
an ide-hd, scsi-hd, scsi-generic or virtio-blk qdev is attached.
Three users remain:
1. eject_device(), via bdrv_is_removable() uses it to determine
whether a block device can eject media.
2. bdrv_info() is monitor command "info block". QMP documentation
says "true if the device is removable, false otherwise". From the
monitor user's point of view, the only sensible interpretation of
"is removable" is "can eject media with monitor commands eject and
change".
A block device can eject media unless a device is attached that
doesn't support it. Switch the two users over to new
bdrv_dev_has_removable_media() that returns exactly that.
3. bdrv_getlength() uses to suppress its length cache when media can
change (see commit 46a4e4e6). Media change is either monitor
command change (updates the length cache), monitor command eject
(doesn't update the length cache, easily fixable), or physical
media change (invalidates length cache, not so easily fixable).
I'm refraining from improving anything here, because this series is
long enough already. Instead, I simply switch it over to
bdrv_dev_has_removable_media() as well.
This changes the behavior of the length cache and of monitor commands
eject and change in two cases:
a. drive not created removable, no device attached
The commit makes the drive removable, and defeats the length cache.
Example: -drive if=none
b. drive created removable, but the attached drive is non-removable,
and doesn't call bdrv_set_removable(..., 0) (most devices don't)
The commit makes the drive non-removable, and enables the length
cache.
Example: -drive if=xen,media=cdrom -M xenpv
The other non-removable devices that don't call
bdrv_set_removable() can't currently use a drive created removable,
either because they aren't qdevified, or because they lack a drive
property. Won't stay that way.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2011-09-06 18:58:51 +02:00
|
|
|
bool bdrv_dev_has_removable_media(BlockDriverState *bs);
|
2011-09-06 18:58:53 +02:00
|
|
|
bool bdrv_dev_is_tray_open(BlockDriverState *bs);
|
2011-09-06 18:58:46 +02:00
|
|
|
bool bdrv_dev_is_medium_locked(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
uint8_t *buf, int nb_sectors);
|
2012-06-29 17:34:29 +02:00
|
|
|
int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
uint8_t *buf, int nb_sectors);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
const uint8_t *buf, int nb_sectors);
|
|
|
|
int bdrv_pread(BlockDriverState *bs, int64_t offset,
|
|
|
|
void *buf, int count);
|
|
|
|
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
|
|
|
|
const void *buf, int count);
|
2010-06-16 16:38:15 +02:00
|
|
|
int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
|
|
|
|
const void *buf, int count);
|
2011-07-14 17:27:13 +02:00
|
|
|
int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
int nb_sectors, QEMUIOVector *qiov);
|
2012-01-18 15:40:42 +01:00
|
|
|
int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
|
2011-07-14 17:27:13 +02:00
|
|
|
int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
int nb_sectors, QEMUIOVector *qiov);
|
2012-02-07 14:27:25 +01:00
|
|
|
/*
|
|
|
|
* Efficiently zero a region of the disk image. Note that this is a regular
|
|
|
|
* I/O request like read or write and should have a reasonable size. This
|
|
|
|
* function is not suitable for zeroing the entire image in a single request
|
|
|
|
* because it may allocate memory for the entire region.
|
|
|
|
*/
|
|
|
|
int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
int nb_sectors);
|
2011-11-14 13:44:26 +01:00
|
|
|
int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
int nb_sectors, int *pnum);
|
2012-05-08 16:52:01 +02:00
|
|
|
int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
|
|
|
|
BlockDriverState *base,
|
|
|
|
int64_t sector_num,
|
|
|
|
int nb_sectors, int *pnum);
|
2012-01-18 15:40:51 +01:00
|
|
|
BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
|
|
|
|
const char *backing_file);
|
2012-08-02 10:22:47 +02:00
|
|
|
int bdrv_get_backing_file_depth(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
|
|
|
|
int64_t bdrv_getlength(BlockDriverState *bs);
|
2011-07-12 13:56:39 +02:00
|
|
|
int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
|
2007-12-17 02:35:20 +01:00
|
|
|
void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_commit(BlockDriverState *bs);
|
2012-03-05 19:10:11 +01:00
|
|
|
int bdrv_commit_all(void);
|
2010-01-12 12:55:17 +01:00
|
|
|
int bdrv_change_backing_file(BlockDriverState *bs,
|
|
|
|
const char *backing_file, const char *backing_fmt);
|
2009-05-10 00:03:42 +02:00
|
|
|
void bdrv_register(BlockDriver *bdrv);
|
2012-09-27 19:29:12 +02:00
|
|
|
int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
|
|
|
|
BlockDriverState *base);
|
|
|
|
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
|
|
|
|
BlockDriverState *bs);
|
2012-09-27 19:29:15 +02:00
|
|
|
BlockDriverState *bdrv_find_base(BlockDriverState *bs);
|
2009-05-10 00:03:42 +02:00
|
|
|
|
2010-06-29 11:43:13 +02:00
|
|
|
|
|
|
|
typedef struct BdrvCheckResult {
|
|
|
|
int corruptions;
|
|
|
|
int leaks;
|
|
|
|
int check_errors;
|
2012-05-11 18:16:54 +02:00
|
|
|
int corruptions_fixed;
|
|
|
|
int leaks_fixed;
|
2012-03-15 13:13:31 +01:00
|
|
|
BlockFragInfo bfi;
|
2010-06-29 11:43:13 +02:00
|
|
|
} BdrvCheckResult;
|
|
|
|
|
2012-05-11 16:07:02 +02:00
|
|
|
typedef enum {
|
|
|
|
BDRV_FIX_LEAKS = 1,
|
|
|
|
BDRV_FIX_ERRORS = 2,
|
|
|
|
} BdrvCheckMode;
|
|
|
|
|
|
|
|
int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
|
2010-06-29 11:43:13 +02:00
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
/* async block I/O */
|
2009-11-02 14:40:41 +01:00
|
|
|
typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
|
2011-06-09 07:06:43 +02:00
|
|
|
int sector_num);
|
2009-01-22 17:59:24 +01:00
|
|
|
BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
QEMUIOVector *iov, int nb_sectors,
|
|
|
|
BlockDriverCompletionFunc *cb, void *opaque);
|
|
|
|
BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
QEMUIOVector *iov, int nb_sectors,
|
|
|
|
BlockDriverCompletionFunc *cb, void *opaque);
|
2009-09-04 19:01:49 +02:00
|
|
|
BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
|
2011-06-09 07:06:43 +02:00
|
|
|
BlockDriverCompletionFunc *cb, void *opaque);
|
2011-10-17 12:32:14 +02:00
|
|
|
BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors,
|
|
|
|
BlockDriverCompletionFunc *cb, void *opaque);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
|
|
|
|
|
2009-09-09 17:53:37 +02:00
|
|
|
typedef struct BlockRequest {
|
|
|
|
/* Fields to be filled by multiwrite caller */
|
|
|
|
int64_t sector;
|
|
|
|
int nb_sectors;
|
|
|
|
QEMUIOVector *qiov;
|
|
|
|
BlockDriverCompletionFunc *cb;
|
|
|
|
void *opaque;
|
|
|
|
|
|
|
|
/* Filled by multiwrite implementation */
|
|
|
|
int error;
|
|
|
|
} BlockRequest;
|
|
|
|
|
|
|
|
int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
|
|
|
|
int num_reqs);
|
|
|
|
|
2009-03-12 20:57:08 +01:00
|
|
|
/* sg packet commands */
|
2009-03-28 18:28:41 +01:00
|
|
|
int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
|
|
|
|
BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
|
|
|
|
unsigned long int req, void *buf,
|
|
|
|
BlockDriverCompletionFunc *cb, void *opaque);
|
2009-03-12 20:57:08 +01:00
|
|
|
|
2011-11-14 22:09:45 +01:00
|
|
|
/* Invalidate any cached metadata used by image formats */
|
|
|
|
void bdrv_invalidate_cache(BlockDriverState *bs);
|
|
|
|
void bdrv_invalidate_cache_all(void);
|
|
|
|
|
2012-03-23 08:36:49 +01:00
|
|
|
void bdrv_clear_incoming_migration_all(void);
|
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
/* Ensure contents are flushed to disk. */
|
2010-10-21 16:43:43 +02:00
|
|
|
int bdrv_flush(BlockDriverState *bs);
|
2011-10-17 12:32:12 +02:00
|
|
|
int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
|
2008-10-06 15:55:43 +02:00
|
|
|
void bdrv_flush_all(void);
|
2010-05-28 04:44:57 +02:00
|
|
|
void bdrv_close_all(void);
|
2011-11-30 13:23:43 +01:00
|
|
|
void bdrv_drain_all(void);
|
2008-10-06 15:55:43 +02:00
|
|
|
|
2010-12-16 19:36:31 +01:00
|
|
|
int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
|
2011-10-17 12:32:14 +02:00
|
|
|
int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);
|
2010-04-14 17:30:35 +02:00
|
|
|
int bdrv_has_zero_init(BlockDriverState *bs);
|
2008-06-05 23:53:49 +02:00
|
|
|
int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
|
2011-06-09 07:06:43 +02:00
|
|
|
int *pnum);
|
2007-11-11 03:51:17 +01:00
|
|
|
|
2012-09-28 17:22:54 +02:00
|
|
|
void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
|
|
|
|
BlockdevOnError on_write_error);
|
2012-09-28 17:22:56 +02:00
|
|
|
BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read);
|
2012-09-28 17:22:57 +02:00
|
|
|
BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error);
|
|
|
|
void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
|
|
|
|
bool is_read, int error);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_is_read_only(BlockDriverState *bs);
|
2007-12-24 17:10:43 +01:00
|
|
|
int bdrv_is_sg(BlockDriverState *bs);
|
2009-09-04 19:01:15 +02:00
|
|
|
int bdrv_enable_write_cache(BlockDriverState *bs);
|
2012-06-06 00:04:52 +02:00
|
|
|
void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_is_inserted(BlockDriverState *bs);
|
|
|
|
int bdrv_media_changed(BlockDriverState *bs);
|
2011-09-06 18:58:47 +02:00
|
|
|
void bdrv_lock_medium(BlockDriverState *bs, bool locked);
|
2012-02-03 19:24:53 +01:00
|
|
|
void bdrv_eject(BlockDriverState *bs, bool eject_flag);
|
2012-06-13 10:11:48 +02:00
|
|
|
const char *bdrv_get_format_name(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
BlockDriverState *bdrv_find(const char *name);
|
2010-06-02 18:55:20 +02:00
|
|
|
BlockDriverState *bdrv_next(BlockDriverState *bs);
|
2009-03-06 00:00:43 +01:00
|
|
|
void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs),
|
|
|
|
void *opaque);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_is_encrypted(BlockDriverState *bs);
|
2009-03-06 00:01:01 +01:00
|
|
|
int bdrv_key_required(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_set_key(BlockDriverState *bs, const char *key);
|
2009-03-06 00:01:01 +01:00
|
|
|
int bdrv_query_missing_keys(void);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
|
|
|
|
void *opaque);
|
|
|
|
const char *bdrv_get_device_name(BlockDriverState *bs);
|
2012-06-05 16:49:24 +02:00
|
|
|
int bdrv_get_flags(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
const uint8_t *buf, int nb_sectors);
|
|
|
|
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
|
2013-01-21 17:09:42 +01:00
|
|
|
void bdrv_round_to_clusters(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors,
|
|
|
|
int64_t *cluster_sector_num,
|
|
|
|
int *cluster_nb_sectors);
|
2007-11-11 03:51:17 +01:00
|
|
|
|
2009-03-06 00:00:48 +01:00
|
|
|
const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_get_backing_filename(BlockDriverState *bs,
|
|
|
|
char *filename, int filename_size);
|
2012-05-08 16:51:50 +02:00
|
|
|
void bdrv_get_full_backing_filename(BlockDriverState *bs,
|
|
|
|
char *dest, size_t sz);
|
2012-10-18 16:49:15 +02:00
|
|
|
BlockInfo *bdrv_query_info(BlockDriverState *s);
|
2012-10-18 16:49:16 +02:00
|
|
|
BlockStats *bdrv_query_stats(const BlockDriverState *bs);
|
savevm: Really verify if a drive supports snapshots
Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.
Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.
So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().
static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.
Later on in do_savevm(), we find:
QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
bdrv_get_device_name(bs1));
}
}
}
bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.
So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.
This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.
bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.
Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-08 15:40:55 +02:00
|
|
|
int bdrv_can_snapshot(BlockDriverState *bs);
|
2010-07-25 22:49:34 +02:00
|
|
|
int bdrv_is_snapshot(BlockDriverState *bs);
|
2010-06-25 10:33:39 +02:00
|
|
|
BlockDriverState *bdrv_snapshots(void);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_snapshot_create(BlockDriverState *bs,
|
|
|
|
QEMUSnapshotInfo *sn_info);
|
|
|
|
int bdrv_snapshot_goto(BlockDriverState *bs,
|
|
|
|
const char *snapshot_id);
|
|
|
|
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
|
|
|
|
int bdrv_snapshot_list(BlockDriverState *bs,
|
|
|
|
QEMUSnapshotInfo **psn_info);
|
2010-09-22 04:58:41 +02:00
|
|
|
int bdrv_snapshot_load_tmp(BlockDriverState *bs,
|
|
|
|
const char *snapshot_name);
|
2007-11-11 03:51:17 +01:00
|
|
|
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
|
|
|
|
|
|
|
|
char *get_human_readable_size(char *buf, int buf_size, int64_t size);
|
|
|
|
int path_is_absolute(const char *path);
|
|
|
|
void path_combine(char *dest, int dest_size,
|
|
|
|
const char *base_path,
|
|
|
|
const char *filename);
|
|
|
|
|
2009-07-10 23:11:57 +02:00
|
|
|
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
|
|
|
|
int64_t pos, int size);
|
2009-04-05 21:10:55 +02:00
|
|
|
|
2009-07-10 23:11:57 +02:00
|
|
|
int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
|
|
|
|
int64_t pos, int size);
|
2009-04-05 21:10:55 +02:00
|
|
|
|
2012-11-30 13:52:09 +01:00
|
|
|
void bdrv_img_create(const char *filename, const char *fmt,
|
|
|
|
const char *base_filename, const char *base_fmt,
|
|
|
|
char *options, uint64_t img_size, int flags, Error **errp);
|
2010-12-16 13:52:15 +01:00
|
|
|
|
2011-09-06 18:58:56 +02:00
|
|
|
void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
|
2011-08-03 15:08:19 +02:00
|
|
|
void *qemu_blockalign(BlockDriverState *bs, size_t size);
|
2013-01-11 16:41:27 +01:00
|
|
|
bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
|
2011-08-03 15:08:19 +02:00
|
|
|
|
2013-01-21 17:09:41 +01:00
|
|
|
#define BDRV_SECTORS_PER_DIRTY_CHUNK (1 << BDRV_LOG_SECTORS_PER_DIRTY_CHUNK)
|
|
|
|
#define BDRV_LOG_SECTORS_PER_DIRTY_CHUNK 11
|
2009-11-30 18:21:19 +01:00
|
|
|
|
2013-01-21 17:09:41 +01:00
|
|
|
struct HBitmapIter;
|
2009-11-02 14:40:41 +01:00
|
|
|
void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
|
|
|
|
int bdrv_get_dirty(BlockDriverState *bs, int64_t sector);
|
2012-10-18 16:49:18 +02:00
|
|
|
void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
|
|
|
|
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
|
2013-01-21 17:09:41 +01:00
|
|
|
void bdrv_dirty_iter_init(BlockDriverState *bs, struct HBitmapIter *hbi);
|
2010-01-26 09:31:48 +01:00
|
|
|
int64_t bdrv_get_dirty_count(BlockDriverState *bs);
|
2010-03-15 17:27:00 +01:00
|
|
|
|
2011-11-28 17:08:47 +01:00
|
|
|
void bdrv_enable_copy_on_read(BlockDriverState *bs);
|
|
|
|
void bdrv_disable_copy_on_read(BlockDriverState *bs);
|
|
|
|
|
2011-01-26 15:12:34 +01:00
|
|
|
void bdrv_set_in_use(BlockDriverState *bs, int in_use);
|
|
|
|
int bdrv_in_use(BlockDriverState *bs);
|
2010-03-15 17:27:00 +01:00
|
|
|
|
2012-11-14 11:43:23 +01:00
|
|
|
#ifdef CONFIG_LINUX_AIO
|
|
|
|
int raw_get_aio_fd(BlockDriverState *bs);
|
|
|
|
#else
|
|
|
|
static inline int raw_get_aio_fd(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-08-25 08:26:01 +02:00
|
|
|
enum BlockAcctType {
|
|
|
|
BDRV_ACCT_READ,
|
|
|
|
BDRV_ACCT_WRITE,
|
|
|
|
BDRV_ACCT_FLUSH,
|
|
|
|
BDRV_MAX_IOTYPE,
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct BlockAcctCookie {
|
|
|
|
int64_t bytes;
|
2011-08-25 08:26:10 +02:00
|
|
|
int64_t start_time_ns;
|
2011-08-25 08:26:01 +02:00
|
|
|
enum BlockAcctType type;
|
|
|
|
} BlockAcctCookie;
|
|
|
|
|
|
|
|
void bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie,
|
|
|
|
int64_t bytes, enum BlockAcctType type);
|
|
|
|
void bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie);
|
|
|
|
|
2010-03-15 17:27:00 +01:00
|
|
|
typedef enum {
|
2010-03-15 17:38:05 +01:00
|
|
|
BLKDBG_L1_UPDATE,
|
|
|
|
|
|
|
|
BLKDBG_L1_GROW_ALLOC_TABLE,
|
|
|
|
BLKDBG_L1_GROW_WRITE_TABLE,
|
|
|
|
BLKDBG_L1_GROW_ACTIVATE_TABLE,
|
|
|
|
|
|
|
|
BLKDBG_L2_LOAD,
|
|
|
|
BLKDBG_L2_UPDATE,
|
|
|
|
BLKDBG_L2_UPDATE_COMPRESSED,
|
|
|
|
BLKDBG_L2_ALLOC_COW_READ,
|
|
|
|
BLKDBG_L2_ALLOC_WRITE,
|
|
|
|
|
|
|
|
BLKDBG_READ_AIO,
|
|
|
|
BLKDBG_READ_BACKING_AIO,
|
|
|
|
BLKDBG_READ_COMPRESSED,
|
|
|
|
|
|
|
|
BLKDBG_WRITE_AIO,
|
|
|
|
BLKDBG_WRITE_COMPRESSED,
|
|
|
|
|
|
|
|
BLKDBG_VMSTATE_LOAD,
|
|
|
|
BLKDBG_VMSTATE_SAVE,
|
|
|
|
|
|
|
|
BLKDBG_COW_READ,
|
|
|
|
BLKDBG_COW_WRITE,
|
|
|
|
|
|
|
|
BLKDBG_REFTABLE_LOAD,
|
|
|
|
BLKDBG_REFTABLE_GROW,
|
|
|
|
|
|
|
|
BLKDBG_REFBLOCK_LOAD,
|
|
|
|
BLKDBG_REFBLOCK_UPDATE,
|
|
|
|
BLKDBG_REFBLOCK_UPDATE_PART,
|
|
|
|
BLKDBG_REFBLOCK_ALLOC,
|
|
|
|
BLKDBG_REFBLOCK_ALLOC_HOOKUP,
|
|
|
|
BLKDBG_REFBLOCK_ALLOC_WRITE,
|
|
|
|
BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
|
|
|
|
BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
|
|
|
|
BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
|
|
|
|
|
|
|
|
BLKDBG_CLUSTER_ALLOC,
|
|
|
|
BLKDBG_CLUSTER_ALLOC_BYTES,
|
|
|
|
BLKDBG_CLUSTER_FREE,
|
|
|
|
|
2010-03-15 17:27:00 +01:00
|
|
|
BLKDBG_EVENT_MAX,
|
|
|
|
} BlkDebugEvent;
|
|
|
|
|
|
|
|
#define BLKDBG_EVENT(bs, evt) bdrv_debug_event(bs, evt)
|
|
|
|
void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event);
|
|
|
|
|
2012-12-06 14:32:58 +01:00
|
|
|
int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
|
|
|
|
const char *tag);
|
|
|
|
int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
|
|
|
|
bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
|
|
|
|
|
2012-07-10 11:12:40 +02:00
|
|
|
#endif
|