2007-11-11 03:51:17 +01:00
|
|
|
#ifndef BLOCK_H
|
|
|
|
#define BLOCK_H
|
|
|
|
|
2008-09-22 21:17:18 +02:00
|
|
|
#include "qemu-aio.h"
|
2009-01-22 17:59:24 +01:00
|
|
|
#include "qemu-common.h"
|
2009-05-18 16:42:10 +02:00
|
|
|
#include "qemu-option.h"
|
2009-12-10 20:16:06 +01:00
|
|
|
#include "qobject.h"
|
2008-09-22 21:17:18 +02:00
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
/* block.c */
|
|
|
|
typedef struct BlockDriver BlockDriver;
|
|
|
|
|
|
|
|
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;
|
|
|
|
} BlockDriverInfo;
|
|
|
|
|
|
|
|
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 */
|
|
|
|
char name[256]; /* user choosen name */
|
|
|
|
uint32_t vm_state_size; /* VM state info size */
|
|
|
|
uint32_t date_sec; /* UTC date of the snapshot */
|
|
|
|
uint32_t date_nsec;
|
|
|
|
uint64_t vm_clock_nsec; /* VM clock relative to boot */
|
|
|
|
} QEMUSnapshotInfo;
|
|
|
|
|
|
|
|
#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 */
|
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-06-02 18:55:17 +02:00
|
|
|
typedef enum {
|
|
|
|
BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,
|
|
|
|
BLOCK_ERR_STOP_ANY
|
|
|
|
} BlockErrorAction;
|
|
|
|
|
2010-02-03 15:41:01 +01:00
|
|
|
typedef enum {
|
|
|
|
BDRV_ACTION_REPORT, BDRV_ACTION_IGNORE, BDRV_ACTION_STOP
|
|
|
|
} BlockMonEventAction;
|
|
|
|
|
|
|
|
void bdrv_mon_event(const BlockDriverState *bdrv,
|
|
|
|
BlockMonEventAction action, int is_read);
|
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
|
|
|
|
|
|
|
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);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_delete(BlockDriverState *bs);
|
|
|
|
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
|
2010-03-31 14:40:27 +02:00
|
|
|
int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
|
|
|
|
BlockDriver *drv);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_close(BlockDriverState *bs);
|
2010-06-29 16:58:30 +02:00
|
|
|
int bdrv_attach(BlockDriverState *bs, DeviceState *qdev);
|
|
|
|
void bdrv_detach(BlockDriverState *bs, DeviceState *qdev);
|
|
|
|
DeviceState *bdrv_get_attached(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);
|
|
|
|
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);
|
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);
|
2008-11-25 22:50:24 +01:00
|
|
|
void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_commit(BlockDriverState *bs);
|
2010-06-02 18:55:18 +02:00
|
|
|
void 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);
|
|
|
|
|
2010-06-29 11:43:13 +02:00
|
|
|
|
|
|
|
typedef struct BdrvCheckResult {
|
|
|
|
int corruptions;
|
|
|
|
int leaks;
|
|
|
|
int check_errors;
|
|
|
|
} BdrvCheckResult;
|
|
|
|
|
|
|
|
int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res);
|
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
/* async block I/O */
|
|
|
|
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
|
|
|
|
typedef void BlockDriverCompletionFunc(void *opaque, int ret);
|
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);
|
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
|
|
|
|
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);
|
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);
|
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);
|
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
|
|
|
|
|
|
|
#define BIOS_ATA_TRANSLATION_AUTO 0
|
|
|
|
#define BIOS_ATA_TRANSLATION_NONE 1
|
|
|
|
#define BIOS_ATA_TRANSLATION_LBA 2
|
|
|
|
#define BIOS_ATA_TRANSLATION_LARGE 3
|
|
|
|
#define BIOS_ATA_TRANSLATION_RECHS 4
|
|
|
|
|
|
|
|
void bdrv_set_geometry_hint(BlockDriverState *bs,
|
|
|
|
int cyls, int heads, int secs);
|
|
|
|
void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
|
|
|
|
void bdrv_get_geometry_hint(BlockDriverState *bs,
|
|
|
|
int *pcyls, int *pheads, int *psecs);
|
2011-02-12 21:43:32 +01:00
|
|
|
typedef enum FDriveType {
|
|
|
|
FDRIVE_DRV_144 = 0x00, /* 1.44 MB 3"5 drive */
|
|
|
|
FDRIVE_DRV_288 = 0x01, /* 2.88 MB 3"5 drive */
|
|
|
|
FDRIVE_DRV_120 = 0x02, /* 1.2 MB 5"25 drive */
|
|
|
|
FDRIVE_DRV_NONE = 0x03, /* No drive connected */
|
|
|
|
} FDriveType;
|
|
|
|
|
|
|
|
void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads,
|
|
|
|
int *max_track, int *last_sect,
|
|
|
|
FDriveType drive_in, FDriveType *drive);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_get_translation_hint(BlockDriverState *bs);
|
2010-06-02 18:55:17 +02:00
|
|
|
void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
|
|
|
|
BlockErrorAction on_write_error);
|
|
|
|
BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read);
|
block: Fix virtual media change for if=none
BlockDriverState member removable controls whether virtual media
change (monitor commands change, eject) is allowed. It is set when
the "type hint" is BDRV_TYPE_CDROM or BDRV_TYPE_FLOPPY.
The type hint is only set by drive_init(). It sets BDRV_TYPE_FLOPPY
for if=floppy. It sets BDRV_TYPE_CDROM for media=cdrom and if=ide,
scsi, xen, or none.
if=ide and if=scsi work, because the type hint makes it a CD-ROM.
if=xen likewise, I think.
For the same reason, if=none works when it's used by ide-drive or
scsi-disk. For other guest devices, there are problems:
* fdc: you can't change virtual media
$ qemu [...] -drive if=none,id=foo,... -global isa-fdc.driveA=foo
QEMU 0.12.50 monitor - type 'help' for more information
(qemu) eject foo
Device 'foo' is not removable
unless you add media=cdrom, but that makes it readonly.
* virtio: if you add media=cdrom, you can change virtual media. If
you eject, the guest gets I/O errors. If you change, the guest sees
the drive's contents suddenly change.
* scsi-generic: if you add media=cdrom, you can change virtual media.
I didn't test what that does to the guest or the physical device,
but it can't be pretty.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-25 13:42:14 +02:00
|
|
|
void bdrv_set_removable(BlockDriverState *bs, int removable);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_is_removable(BlockDriverState *bs);
|
|
|
|
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);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_is_inserted(BlockDriverState *bs);
|
|
|
|
int bdrv_media_changed(BlockDriverState *bs);
|
|
|
|
int bdrv_is_locked(BlockDriverState *bs);
|
|
|
|
void bdrv_set_locked(BlockDriverState *bs, int locked);
|
2009-05-27 11:06:11 +02:00
|
|
|
int bdrv_eject(BlockDriverState *bs, int eject_flag);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_set_change_cb(BlockDriverState *bs,
|
2011-01-24 13:32:41 +01:00
|
|
|
void (*change_cb)(void *opaque, int reason),
|
|
|
|
void *opaque);
|
2007-11-11 03:51:17 +01:00
|
|
|
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
|
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);
|
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
|
|
|
|
2010-12-16 13:52:15 +01:00
|
|
|
int 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);
|
|
|
|
|
2009-11-30 18:21:22 +01:00
|
|
|
#define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
|
2009-11-30 18:21:19 +01:00
|
|
|
|
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);
|
2009-11-30 18:21:19 +01:00
|
|
|
void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
|
|
|
|
int nr_sectors);
|
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-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
|
|
|
|
|
|
|
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,
|
|
|
|
BLKDBG_READ_AIO,
|
|
|
|
BLKDBG_READ_BACKING,
|
|
|
|
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);
|
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
#endif
|