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"
|
2016-03-09 10:52:44 +01:00
|
|
|
#include "qemu/iov.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/option.h"
|
2015-09-01 15:48:02 +02:00
|
|
|
#include "qemu/coroutine.h"
|
2014-09-05 15:46:18 +02:00
|
|
|
#include "block/accounting.h"
|
2016-03-08 05:44:55 +01:00
|
|
|
#include "block/dirty-bitmap.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"
|
2016-03-08 05:44:53 +01:00
|
|
|
#include "qemu/hbitmap.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;
|
2015-06-15 13:24:19 +02:00
|
|
|
typedef struct BdrvChild BdrvChild;
|
2015-04-08 13:43:47 +02:00
|
|
|
typedef struct BdrvChildRole BdrvChildRole;
|
2015-11-06 00:13:15 +01:00
|
|
|
typedef struct BlockJobTxn BlockJobTxn;
|
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;
|
2013-10-24 12:06:53 +02:00
|
|
|
/*
|
|
|
|
* True if unallocated blocks read back as zeroes. This is equivalent
|
2015-08-26 13:17:13 +02:00
|
|
|
* to the LBPRZ flag in the SCSI logical block provisioning page.
|
2013-10-24 12:06:53 +02:00
|
|
|
*/
|
|
|
|
bool unallocated_blocks_are_zero;
|
|
|
|
/*
|
|
|
|
* True if the driver can optimize writing zeroes by unmapping
|
|
|
|
* sectors. This is equivalent to the BLKDISCARDZEROES ioctl in Linux
|
|
|
|
* with the difference that in qemu a discard is allowed to silently
|
|
|
|
* fail. Therefore we have to use bdrv_write_zeroes with the
|
|
|
|
* BDRV_REQ_MAY_UNMAP flag for an optimized zero write with unmapping.
|
|
|
|
* After this call the driver has to guarantee that the contents read
|
|
|
|
* back as zero. It is additionally required that the block device is
|
|
|
|
* opened with BDRV_O_UNMAP flag for this to work.
|
|
|
|
*/
|
|
|
|
bool can_write_zeroes_with_unmap;
|
2014-05-06 15:08:43 +02:00
|
|
|
/*
|
|
|
|
* True if this block driver only supports compressed writes
|
|
|
|
*/
|
|
|
|
bool needs_compressed_writes;
|
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;
|
2013-02-07 17:15:04 +01:00
|
|
|
uint64_t compressed_clusters;
|
2012-03-15 13:13:31 +01:00
|
|
|
} BlockFragInfo;
|
|
|
|
|
2013-10-24 12:06:50 +02:00
|
|
|
typedef enum {
|
2015-09-08 05:28:32 +02:00
|
|
|
BDRV_REQ_COPY_ON_READ = 0x1,
|
|
|
|
BDRV_REQ_ZERO_WRITE = 0x2,
|
2013-10-24 12:06:52 +02:00
|
|
|
/* The BDRV_REQ_MAY_UNMAP flag is used to indicate that the block driver
|
|
|
|
* is allowed to optimize a write zeroes request by unmapping (discarding)
|
|
|
|
* blocks if it is guaranteed that the result will read back as
|
|
|
|
* zeroes. The flag is only passed to the driver if the block device is
|
|
|
|
* opened with BDRV_O_UNMAP.
|
|
|
|
*/
|
2015-09-08 05:28:32 +02:00
|
|
|
BDRV_REQ_MAY_UNMAP = 0x4,
|
2015-12-01 10:36:28 +01:00
|
|
|
BDRV_REQ_NO_SERIALISING = 0x8,
|
2013-10-24 12:06:50 +02:00
|
|
|
} BdrvRequestFlags;
|
|
|
|
|
2015-02-16 12:47:54 +01:00
|
|
|
typedef struct BlockSizes {
|
|
|
|
uint32_t phys;
|
|
|
|
uint32_t log;
|
|
|
|
} BlockSizes;
|
|
|
|
|
|
|
|
typedef struct HDGeometry {
|
|
|
|
uint32_t heads;
|
|
|
|
uint32_t sectors;
|
|
|
|
uint32_t cylinders;
|
|
|
|
} HDGeometry;
|
|
|
|
|
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 */
|
2014-04-11 19:16:36 +02:00
|
|
|
#define BDRV_O_TEMPORARY 0x0010 /* delete the file after use */
|
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 */
|
2016-01-13 15:56:06 +01:00
|
|
|
#define BDRV_O_INACTIVE 0x0800 /* consistency hint for migration handoff */
|
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 */
|
2013-02-08 14:06:11 +01:00
|
|
|
#define BDRV_O_UNMAP 0x4000 /* execute guest UNMAP/TRIM operations */
|
2014-02-18 18:33:07 +01:00
|
|
|
#define BDRV_O_PROTOCOL 0x8000 /* if no block driver is explicitly given:
|
|
|
|
select an appropriate protocol driver,
|
|
|
|
ignoring the format layer */
|
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
|
|
|
|
2015-04-07 16:55:00 +02:00
|
|
|
|
|
|
|
/* Option names of options parsed by the block layer */
|
|
|
|
|
|
|
|
#define BDRV_OPT_CACHE_WB "cache.writeback"
|
|
|
|
#define BDRV_OPT_CACHE_DIRECT "cache.direct"
|
|
|
|
#define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush"
|
|
|
|
|
|
|
|
|
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
|
|
|
|
2015-02-06 11:54:11 +01:00
|
|
|
#define BDRV_REQUEST_MAX_SECTORS MIN(SIZE_MAX >> BDRV_SECTOR_BITS, \
|
|
|
|
INT_MAX >> BDRV_SECTOR_BITS)
|
|
|
|
|
2014-11-10 10:10:38 +01:00
|
|
|
/*
|
|
|
|
* Allocation status flags
|
2016-01-26 04:58:48 +01:00
|
|
|
* BDRV_BLOCK_DATA: data is read from a file returned by bdrv_get_block_status.
|
2013-09-04 19:00:29 +02:00
|
|
|
* BDRV_BLOCK_ZERO: sectors read as zero
|
2016-01-26 04:58:48 +01:00
|
|
|
* BDRV_BLOCK_OFFSET_VALID: sector stored as raw data in a file returned by
|
|
|
|
* bdrv_get_block_status.
|
2014-05-06 15:25:36 +02:00
|
|
|
* BDRV_BLOCK_ALLOCATED: the content of the block is determined by this
|
|
|
|
* layer (as opposed to the backing file)
|
2013-10-08 14:43:14 +02:00
|
|
|
* BDRV_BLOCK_RAW: used internally to indicate that the request
|
|
|
|
* was answered by the raw driver and that one
|
|
|
|
* should look in bs->file directly.
|
2013-09-04 19:00:29 +02:00
|
|
|
*
|
|
|
|
* If BDRV_BLOCK_OFFSET_VALID is set, bits 9-62 represent the offset in
|
|
|
|
* bs->file where sector data can be read from as raw data.
|
|
|
|
*
|
|
|
|
* DATA == 0 && ZERO == 0 means that data is read from backing_hd if present.
|
|
|
|
*
|
|
|
|
* DATA ZERO OFFSET_VALID
|
|
|
|
* t t t sectors read as zero, bs->file is zero at offset
|
|
|
|
* t f t sectors read as valid from bs->file at offset
|
|
|
|
* f t t sectors preallocated, read as zero, bs->file not
|
|
|
|
* necessarily zero at offset
|
|
|
|
* f f t sectors preallocated but read from backing_hd,
|
|
|
|
* bs->file contains garbage at offset
|
|
|
|
* t t f sectors preallocated, read as zero, unknown offset
|
|
|
|
* t f f sectors read from unknown file or offset
|
|
|
|
* f t f not allocated or unknown offset, read as zero
|
|
|
|
* f f f not allocated or unknown offset, read from backing_hd
|
|
|
|
*/
|
2014-05-06 15:25:36 +02:00
|
|
|
#define BDRV_BLOCK_DATA 0x01
|
|
|
|
#define BDRV_BLOCK_ZERO 0x02
|
|
|
|
#define BDRV_BLOCK_OFFSET_VALID 0x04
|
|
|
|
#define BDRV_BLOCK_RAW 0x08
|
|
|
|
#define BDRV_BLOCK_ALLOCATED 0x10
|
2013-09-04 19:00:29 +02:00
|
|
|
#define BDRV_BLOCK_OFFSET_MASK BDRV_SECTOR_MASK
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
|
|
|
|
|
|
|
|
typedef struct BDRVReopenState {
|
|
|
|
BlockDriverState *bs;
|
|
|
|
int flags;
|
2015-04-10 17:50:50 +02:00
|
|
|
QDict *options;
|
2015-05-08 16:15:03 +02:00
|
|
|
QDict *explicit_options;
|
2012-09-20 21:13:19 +02:00
|
|
|
void *opaque;
|
|
|
|
} BDRVReopenState;
|
|
|
|
|
2014-05-23 15:29:41 +02:00
|
|
|
/*
|
|
|
|
* Block operation types
|
|
|
|
*/
|
|
|
|
typedef enum BlockOpType {
|
|
|
|
BLOCK_OP_TYPE_BACKUP_SOURCE,
|
|
|
|
BLOCK_OP_TYPE_BACKUP_TARGET,
|
|
|
|
BLOCK_OP_TYPE_CHANGE,
|
2014-09-11 07:14:00 +02:00
|
|
|
BLOCK_OP_TYPE_COMMIT_SOURCE,
|
|
|
|
BLOCK_OP_TYPE_COMMIT_TARGET,
|
2014-05-23 15:29:41 +02:00
|
|
|
BLOCK_OP_TYPE_DATAPLANE,
|
|
|
|
BLOCK_OP_TYPE_DRIVE_DEL,
|
|
|
|
BLOCK_OP_TYPE_EJECT,
|
|
|
|
BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
|
|
|
|
BLOCK_OP_TYPE_INTERNAL_SNAPSHOT,
|
|
|
|
BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE,
|
2015-12-24 05:45:02 +01:00
|
|
|
BLOCK_OP_TYPE_MIRROR_SOURCE,
|
2015-12-24 05:45:04 +01:00
|
|
|
BLOCK_OP_TYPE_MIRROR_TARGET,
|
2014-05-23 15:29:41 +02:00
|
|
|
BLOCK_OP_TYPE_RESIZE,
|
|
|
|
BLOCK_OP_TYPE_STREAM,
|
2014-06-27 18:25:25 +02:00
|
|
|
BLOCK_OP_TYPE_REPLACE,
|
2014-05-23 15:29:41 +02:00
|
|
|
BLOCK_OP_TYPE_MAX,
|
|
|
|
} BlockOpType;
|
2012-09-20 21:13:19 +02:00
|
|
|
|
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 */
|
2015-06-08 18:17:44 +02:00
|
|
|
void bdrv_io_limits_enable(BlockDriverState *bs, const char *group);
|
2011-11-08 06:00:14 +01:00
|
|
|
void bdrv_io_limits_disable(BlockDriverState *bs);
|
2015-06-08 18:17:44 +02:00
|
|
|
void bdrv_io_limits_update_group(BlockDriverState *bs, const char *group);
|
2011-11-03 09:57:25 +01:00
|
|
|
|
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);
|
2013-07-10 15:47:39 +02:00
|
|
|
BlockDriver *bdrv_find_protocol(const char *filename,
|
2015-02-05 19:58:12 +01:00
|
|
|
bool allow_protocol_prefix,
|
|
|
|
Error **errp);
|
2007-11-11 03:51:17 +01:00
|
|
|
BlockDriver *bdrv_find_format(const char *format_name);
|
2009-05-18 16:42:10 +02:00
|
|
|
int bdrv_create(BlockDriver *drv, const char* filename,
|
2014-06-05 11:21:11 +02:00
|
|
|
QemuOpts *opts, Error **errp);
|
|
|
|
int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp);
|
2014-10-07 13:59:12 +02:00
|
|
|
BlockDriverState *bdrv_new_root(void);
|
2014-10-07 13:59:03 +02:00
|
|
|
BlockDriverState *bdrv_new(void);
|
2012-02-28 21:54:06 +01:00
|
|
|
void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top);
|
2015-09-15 11:58:23 +02:00
|
|
|
void bdrv_replace_in_backing_chain(BlockDriverState *old,
|
|
|
|
BlockDriverState *new);
|
|
|
|
|
2011-08-04 13:26:51 +02:00
|
|
|
int bdrv_parse_cache_flags(const char *mode, int *flags);
|
2013-02-08 14:06:11 +01:00
|
|
|
int bdrv_parse_discard_flags(const char *mode, int *flags);
|
2015-06-15 13:24:19 +02:00
|
|
|
BdrvChild *bdrv_open_child(const char *filename,
|
|
|
|
QDict *options, const char *bdref_key,
|
|
|
|
BlockDriverState* parent,
|
|
|
|
const BdrvChildRole *child_role,
|
|
|
|
bool allow_none, Error **errp);
|
2014-05-23 15:29:45 +02:00
|
|
|
void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd);
|
2015-01-16 18:23:41 +01:00
|
|
|
int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
|
|
|
|
const char *bdref_key, Error **errp);
|
2014-02-18 18:33:06 +01:00
|
|
|
int bdrv_open(BlockDriverState **pbs, const char *filename,
|
2015-08-26 19:47:49 +02:00
|
|
|
const char *reference, QDict *options, int flags, Error **errp);
|
2012-09-20 21:13:19 +02:00
|
|
|
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
|
2015-04-10 17:50:50 +02:00
|
|
|
BlockDriverState *bs,
|
|
|
|
QDict *options, int flags);
|
2012-09-20 21:13:19 +02:00
|
|
|
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
|
|
|
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);
|
2013-07-11 14:16:22 +02:00
|
|
|
int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
|
2013-10-24 12:06:51 +02:00
|
|
|
int nb_sectors, BdrvRequestFlags flags);
|
2014-10-07 13:59:14 +02:00
|
|
|
BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
int nb_sectors, BdrvRequestFlags flags,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
2013-10-24 12:07:03 +02:00
|
|
|
int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags);
|
2007-11-11 03:51:17 +01:00
|
|
|
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);
|
2013-04-05 21:27:55 +02:00
|
|
|
int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov);
|
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);
|
2015-12-01 10:36:28 +01:00
|
|
|
int coroutine_fn bdrv_co_readv_no_serialising(BlockDriverState *bs,
|
2015-09-08 05:28:32 +02:00
|
|
|
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,
|
2013-10-24 12:06:51 +02:00
|
|
|
int nb_sectors, BdrvRequestFlags flags);
|
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);
|
2014-07-18 20:24:56 +02:00
|
|
|
void bdrv_refresh_filename(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
|
2014-06-26 13:23:17 +02:00
|
|
|
int64_t bdrv_nb_sectors(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
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);
|
2014-07-16 17:48:16 +02:00
|
|
|
void bdrv_refresh_limits(BlockDriverState *bs, Error **errp);
|
2007-11-11 03:51:17 +01:00
|
|
|
int bdrv_commit(BlockDriverState *bs);
|
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,
|
block: extend block-commit to accept a string for the backing file
On some image chains, QEMU may not always be able to resolve the
filenames properly, when updating the backing file of an image
after a block commit.
For instance, certain relative pathnames may fail, or drives may
have been specified originally by file descriptor (e.g. /dev/fd/???),
or a relative protocol pathname may have been used.
In these instances, QEMU may lack the information to be able to make
the correct choice, but the user or management layer most likely does
have that knowledge.
With this extension to the block-commit api, the user is able to change
the backing file of the overlay image as part of the block-commit
operation.
This allows the change to be 'safe', in the sense that if the attempt
to write the overlay image metadata fails, then the block-commit
operation returns failure, without disrupting the guest.
If the commit top is the active layer, then specifying the backing
file string will be treated as an error (there is no overlay image
to modify in that case).
If a backing file string is not specified in the command, the backing
file string to use is determined in the same manner as it was
previously.
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-25 21:40:10 +02:00
|
|
|
BlockDriverState *base,
|
|
|
|
const char *backing_file_str);
|
2012-09-27 19:29:12 +02:00
|
|
|
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;
|
2013-01-28 12:59:46 +01:00
|
|
|
int64_t image_end_offset;
|
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
|
|
|
|
2014-10-27 11:12:50 +01:00
|
|
|
/* The units of offset and total_work_size may be chosen arbitrarily by the
|
|
|
|
* block driver; total_work_size may change during the course of the amendment
|
|
|
|
* operation */
|
|
|
|
typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset,
|
2015-07-27 17:51:32 +02:00
|
|
|
int64_t total_work_size, void *opaque);
|
2014-10-27 11:12:50 +01:00
|
|
|
int bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *opts,
|
2015-07-27 17:51:32 +02:00
|
|
|
BlockDriverAmendStatusCB *status_cb, void *cb_opaque);
|
2013-09-03 10:09:50 +02:00
|
|
|
|
2013-10-02 14:33:48 +02:00
|
|
|
/* external snapshots */
|
2014-01-23 21:31:36 +01:00
|
|
|
bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
|
|
|
|
BlockDriverState *candidate);
|
|
|
|
bool bdrv_is_first_non_filter(BlockDriverState *candidate);
|
2013-10-02 14:33:48 +02:00
|
|
|
|
2014-06-27 18:25:25 +02:00
|
|
|
/* check if a named node can be replaced when doing drive-mirror */
|
2015-07-17 04:12:22 +02:00
|
|
|
BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
|
|
|
|
const char *node_name, Error **errp);
|
2014-06-27 18:25:25 +02:00
|
|
|
|
2007-11-11 03:51:17 +01:00
|
|
|
/* async block I/O */
|
2014-10-07 13:59:14 +02:00
|
|
|
BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
QEMUIOVector *iov, int nb_sectors,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
2014-10-07 13:59:14 +02:00
|
|
|
BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
QEMUIOVector *iov, int nb_sectors,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
2014-10-07 13:59:14 +02:00
|
|
|
BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
2014-10-07 13:59:14 +02:00
|
|
|
BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
2014-10-07 13:59:14 +02:00
|
|
|
void bdrv_aio_cancel(BlockAIOCB *acb);
|
|
|
|
void bdrv_aio_cancel_async(BlockAIOCB *acb);
|
2007-11-11 03:51:17 +01:00
|
|
|
|
2009-09-09 17:53:37 +02:00
|
|
|
typedef struct BlockRequest {
|
|
|
|
/* Fields to be filled by multiwrite caller */
|
2015-11-09 11:16:50 +01:00
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
int64_t sector;
|
|
|
|
int nb_sectors;
|
|
|
|
int flags;
|
|
|
|
QEMUIOVector *qiov;
|
|
|
|
};
|
|
|
|
struct {
|
|
|
|
int req;
|
|
|
|
void *buf;
|
|
|
|
};
|
|
|
|
};
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb;
|
2009-09-09 17:53:37 +02:00
|
|
|
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);
|
2014-10-07 13:59:14 +02:00
|
|
|
BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
|
2009-03-28 18:28:41 +01:00
|
|
|
unsigned long int req, void *buf,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *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 */
|
2014-03-12 15:59:16 +01:00
|
|
|
void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp);
|
|
|
|
void bdrv_invalidate_cache_all(Error **errp);
|
2015-12-22 14:07:08 +01:00
|
|
|
int bdrv_inactivate_all(void);
|
2011-11-14 22:09:45 +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);
|
2011-10-17 12:32:12 +02:00
|
|
|
int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
|
2010-05-28 04:44:57 +02:00
|
|
|
void bdrv_close_all(void);
|
2014-10-21 13:03:55 +02:00
|
|
|
void bdrv_drain(BlockDriverState *bs);
|
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);
|
2013-06-28 12:47:42 +02:00
|
|
|
int bdrv_has_zero_init_1(BlockDriverState *bs);
|
2010-04-14 17:30:35 +02:00
|
|
|
int bdrv_has_zero_init(BlockDriverState *bs);
|
2013-10-24 12:06:54 +02:00
|
|
|
bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
|
|
|
|
bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
|
2013-09-04 19:00:28 +02:00
|
|
|
int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
|
2016-01-26 04:58:48 +01:00
|
|
|
int nb_sectors, int *pnum,
|
|
|
|
BlockDriverState **file);
|
2015-06-08 07:56:07 +02:00
|
|
|
int64_t bdrv_get_block_status_above(BlockDriverState *bs,
|
|
|
|
BlockDriverState *base,
|
|
|
|
int64_t sector_num,
|
2016-01-26 04:58:48 +01:00
|
|
|
int nb_sectors, int *pnum,
|
|
|
|
BlockDriverState **file);
|
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);
|
2013-02-13 09:09:39 +01:00
|
|
|
int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
|
|
|
|
int64_t sector_num, int nb_sectors, int *pnum);
|
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);
|
2015-10-19 17:53:11 +02:00
|
|
|
bool bdrv_is_inserted(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
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);
|
2014-01-23 21:31:32 +01:00
|
|
|
BlockDriverState *bdrv_find_node(const char *node_name);
|
2015-04-17 13:52:43 +02:00
|
|
|
BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);
|
2014-01-23 21:31:35 +01:00
|
|
|
BlockDriverState *bdrv_lookup_bs(const char *device,
|
|
|
|
const char *node_name,
|
|
|
|
Error **errp);
|
2014-06-25 21:40:09 +02:00
|
|
|
bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base);
|
2014-10-31 04:32:54 +01:00
|
|
|
BlockDriverState *bdrv_next_node(BlockDriverState *bs);
|
2010-06-02 18:55:20 +02:00
|
|
|
BlockDriverState *bdrv_next(BlockDriverState *bs);
|
2016-03-16 19:54:41 +01:00
|
|
|
BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
|
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);
|
2015-01-29 10:37:00 +01:00
|
|
|
void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp);
|
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);
|
2014-10-31 04:32:55 +01:00
|
|
|
const char *bdrv_get_node_name(const BlockDriverState *bs);
|
2014-10-07 13:59:11 +02:00
|
|
|
const char *bdrv_get_device_name(const BlockDriverState *bs);
|
2015-04-08 11:29:18 +02:00
|
|
|
const char *bdrv_get_device_or_node_name(const 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-10-09 10:46:16 +02:00
|
|
|
ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs);
|
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,
|
2014-11-26 17:20:26 +01:00
|
|
|
char *dest, size_t sz, Error **errp);
|
2014-11-26 17:20:25 +01:00
|
|
|
void bdrv_get_full_backing_filename_from_filename(const char *backed,
|
|
|
|
const char *backing,
|
2014-11-26 17:20:26 +01:00
|
|
|
char *dest, size_t sz,
|
|
|
|
Error **errp);
|
2010-07-25 22:49:34 +02:00
|
|
|
int bdrv_is_snapshot(BlockDriverState *bs);
|
2007-11-11 03:51:17 +01:00
|
|
|
|
2014-12-03 14:57:22 +01:00
|
|
|
int path_has_protocol(const char *path);
|
2007-11-11 03:51:17 +01:00
|
|
|
int path_is_absolute(const char *path);
|
|
|
|
void path_combine(char *dest, int dest_size,
|
|
|
|
const char *base_path,
|
|
|
|
const char *filename);
|
|
|
|
|
2013-04-05 21:27:53 +02:00
|
|
|
int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
|
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,
|
2013-02-13 09:09:40 +01:00
|
|
|
char *options, uint64_t img_size, int flags,
|
|
|
|
Error **errp, bool quiet);
|
2010-12-16 13:52:15 +01:00
|
|
|
|
2013-11-28 10:23:32 +01:00
|
|
|
/* Returns the alignment in bytes that is required so that no bounce buffer
|
|
|
|
* is required throughout the stack */
|
2015-05-12 16:30:55 +02:00
|
|
|
size_t bdrv_min_mem_align(BlockDriverState *bs);
|
|
|
|
/* Returns optimal alignment in bytes for bounce buffer */
|
2013-11-28 10:23:32 +01:00
|
|
|
size_t bdrv_opt_mem_align(BlockDriverState *bs);
|
2011-08-03 15:08:19 +02:00
|
|
|
void *qemu_blockalign(BlockDriverState *bs, size_t size);
|
2014-10-22 14:09:27 +02:00
|
|
|
void *qemu_blockalign0(BlockDriverState *bs, size_t size);
|
2014-05-20 12:24:05 +02:00
|
|
|
void *qemu_try_blockalign(BlockDriverState *bs, size_t size);
|
2014-10-22 14:09:27 +02:00
|
|
|
void *qemu_try_blockalign0(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
|
|
|
|
2011-11-28 17:08:47 +01:00
|
|
|
void bdrv_enable_copy_on_read(BlockDriverState *bs);
|
|
|
|
void bdrv_disable_copy_on_read(BlockDriverState *bs);
|
|
|
|
|
2013-08-23 03:14:46 +02:00
|
|
|
void bdrv_ref(BlockDriverState *bs);
|
|
|
|
void bdrv_unref(BlockDriverState *bs);
|
2015-06-15 13:51:04 +02:00
|
|
|
void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child);
|
2010-03-15 17:27:00 +01:00
|
|
|
|
2014-05-23 15:29:42 +02:00
|
|
|
bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
|
|
|
|
void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason);
|
|
|
|
void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason);
|
|
|
|
void bdrv_op_block_all(BlockDriverState *bs, Error *reason);
|
|
|
|
void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason);
|
|
|
|
bool bdrv_op_blocker_is_empty(BlockDriverState *bs);
|
|
|
|
|
2015-06-16 14:19:22 +02:00
|
|
|
#define BLKDBG_EVENT(child, evt) \
|
|
|
|
do { \
|
|
|
|
if (child) { \
|
|
|
|
bdrv_debug_event(child->bs, evt); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2015-11-18 09:52:54 +01:00
|
|
|
void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
|
2010-03-15 17:27:00 +01:00
|
|
|
|
2012-12-06 14:32:58 +01:00
|
|
|
int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
|
|
|
|
const char *tag);
|
2013-11-20 03:01:54 +01:00
|
|
|
int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag);
|
2012-12-06 14:32:58 +01:00
|
|
|
int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
|
|
|
|
bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
|
|
|
|
|
2014-05-15 13:22:05 +02:00
|
|
|
/**
|
|
|
|
* bdrv_get_aio_context:
|
|
|
|
*
|
|
|
|
* Returns: the currently bound #AioContext
|
|
|
|
*/
|
|
|
|
AioContext *bdrv_get_aio_context(BlockDriverState *bs);
|
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
/**
|
|
|
|
* bdrv_set_aio_context:
|
|
|
|
*
|
|
|
|
* Changes the #AioContext used for fd handlers, timers, and BHs by this
|
|
|
|
* BlockDriverState and all its children.
|
|
|
|
*
|
block: Forbid bdrv_set_aio_context outside BQL
Even if the caller has both the old and the new AioContext's, there can
be a deadlock, due to the leading bdrv_drain_all.
Suppose there are four io threads (A, B, A0, B0) with A and B owning a
BDS for each (bs_a, bs_b); Now A wants to move bs_a to iothread A0, and
B wants to move bs_b to B0, at the same time:
iothread A iothread B
--------------------------------------------------------------------------
aio_context_acquire(A0) /* OK */ aio_context_acquire(B0) /* OK */
bdrv_set_aio_context(bs_a, A0) bdrv_set_aio_context(bs_b, B0)
-> bdrv_drain_all() -> bdrv_drain_all()
-> acquire A /* OK */ -> acquire A /* blocked */
-> acquire B /* blocked */ -> acquire B
... ...
Deadlock happens because A is waiting for B, and B is waiting for A.
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <1423969591-23646-2-git-send-email-famz@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-02-15 04:06:30 +01:00
|
|
|
* This function must be called with iothread lock held.
|
2014-05-08 16:34:37 +02:00
|
|
|
*/
|
|
|
|
void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context);
|
2015-02-16 12:47:54 +01:00
|
|
|
int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz);
|
|
|
|
int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo);
|
2014-05-08 16:34:37 +02:00
|
|
|
|
2014-07-04 12:04:33 +02:00
|
|
|
void bdrv_io_plug(BlockDriverState *bs);
|
|
|
|
void bdrv_io_unplug(BlockDriverState *bs);
|
|
|
|
void bdrv_flush_io_queue(BlockDriverState *bs);
|
|
|
|
|
2015-10-23 05:08:09 +02:00
|
|
|
/**
|
|
|
|
* bdrv_drained_begin:
|
|
|
|
*
|
|
|
|
* Begin a quiesced section for exclusive access to the BDS, by disabling
|
|
|
|
* external request sources including NBD server and device model. Note that
|
|
|
|
* this doesn't block timers or coroutines from submitting more requests, which
|
|
|
|
* means block_job_pause is still necessary.
|
|
|
|
*
|
|
|
|
* This function can be recursive.
|
|
|
|
*/
|
|
|
|
void bdrv_drained_begin(BlockDriverState *bs);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* bdrv_drained_end:
|
|
|
|
*
|
|
|
|
* End a quiescent section started by bdrv_drained_begin().
|
|
|
|
*/
|
|
|
|
void bdrv_drained_end(BlockDriverState *bs);
|
|
|
|
|
2012-07-10 11:12:40 +02:00
|
|
|
#endif
|