2004-08-01 23:59:26 +02:00
|
|
|
/*
|
|
|
|
* QEMU System Emulator block driver
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2004-08-01 23:59:26 +02:00
|
|
|
* Copyright (c) 2003 Fabrice Bellard
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2004-08-01 23:59:26 +02:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
#ifndef BLOCK_INT_H
|
|
|
|
#define BLOCK_INT_H
|
|
|
|
|
2014-09-05 15:46:16 +02:00
|
|
|
#include "block/accounting.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/option.h"
|
|
|
|
#include "qemu/queue.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/coroutine.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/timer.h"
|
2011-09-21 22:16:47 +02:00
|
|
|
#include "qapi-types.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "monitor/monitor.h"
|
2013-01-21 17:09:41 +01:00
|
|
|
#include "qemu/hbitmap.h"
|
2013-05-25 05:09:44 +02:00
|
|
|
#include "block/snapshot.h"
|
2013-08-21 17:02:47 +02:00
|
|
|
#include "qemu/main-loop.h"
|
2013-09-02 14:14:39 +02:00
|
|
|
#include "qemu/throttle.h"
|
2007-11-11 03:51:17 +01:00
|
|
|
|
2012-07-27 10:05:22 +02:00
|
|
|
#define BLOCK_FLAG_ENCRYPT 1
|
|
|
|
#define BLOCK_FLAG_COMPAT6 4
|
|
|
|
#define BLOCK_FLAG_LAZY_REFCOUNTS 8
|
2007-09-16 23:59:02 +02:00
|
|
|
|
2012-07-27 10:05:22 +02:00
|
|
|
#define BLOCK_OPT_SIZE "size"
|
|
|
|
#define BLOCK_OPT_ENCRYPT "encryption"
|
|
|
|
#define BLOCK_OPT_COMPAT6 "compat6"
|
|
|
|
#define BLOCK_OPT_BACKING_FILE "backing_file"
|
|
|
|
#define BLOCK_OPT_BACKING_FMT "backing_fmt"
|
|
|
|
#define BLOCK_OPT_CLUSTER_SIZE "cluster_size"
|
|
|
|
#define BLOCK_OPT_TABLE_SIZE "table_size"
|
|
|
|
#define BLOCK_OPT_PREALLOC "preallocation"
|
|
|
|
#define BLOCK_OPT_SUBFMT "subformat"
|
|
|
|
#define BLOCK_OPT_COMPAT_LEVEL "compat"
|
|
|
|
#define BLOCK_OPT_LAZY_REFCOUNTS "lazy_refcounts"
|
2013-01-30 00:26:52 +01:00
|
|
|
#define BLOCK_OPT_ADAPTER_TYPE "adapter_type"
|
2013-11-07 15:56:38 +01:00
|
|
|
#define BLOCK_OPT_REDUNDANCY "redundancy"
|
qemu-img create: add 'nocow' option
Add 'nocow' option so that users could have a chance to set NOCOW flag to
newly created files. It's useful on btrfs file system to enhance performance.
Btrfs has low performance when hosting VM images, even more when the guest
in those VM are also using btrfs as file system. One way to mitigate this bad
performance is to turn off COW attributes on VM files. Generally, there are
two ways to turn off NOCOW on btrfs: a) by mounting fs with nodatacow, then
all newly created files will be NOCOW. b) per file. Add the NOCOW file
attribute. It could only be done to empty or new files.
This patch tries the second way, according to the option, it could add NOCOW
per file.
For most block drivers, since the create file step is in raw-posix.c, so we
can do setting NOCOW flag ioctl in raw-posix.c only.
But there are some exceptions, like block/vpc.c and block/vdi.c, they are
creating file by calling qemu_open directly. For them, do the same setting
NOCOW flag ioctl work in them separately.
[Fixed up 082.out due to the new 'nocow' creation option
--Stefan]
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-30 08:29:58 +02:00
|
|
|
#define BLOCK_OPT_NOCOW "nocow"
|
2009-05-18 16:42:10 +02:00
|
|
|
|
2014-11-20 16:27:11 +01:00
|
|
|
#define BLOCK_PROBE_BUF_SIZE 512
|
|
|
|
|
2013-06-24 17:13:10 +02:00
|
|
|
typedef struct BdrvTrackedRequest {
|
|
|
|
BlockDriverState *bs;
|
2013-12-03 15:31:25 +01:00
|
|
|
int64_t offset;
|
|
|
|
unsigned int bytes;
|
2013-06-24 17:13:10 +02:00
|
|
|
bool is_write;
|
2013-12-04 17:08:50 +01:00
|
|
|
|
2013-12-04 16:43:44 +01:00
|
|
|
bool serialising;
|
2013-12-04 17:08:50 +01:00
|
|
|
int64_t overlap_offset;
|
|
|
|
unsigned int overlap_bytes;
|
|
|
|
|
2013-06-24 17:13:10 +02:00
|
|
|
QLIST_ENTRY(BdrvTrackedRequest) list;
|
|
|
|
Coroutine *co; /* owner, used for deadlock detection */
|
|
|
|
CoQueue wait_queue; /* coroutines blocked on this request */
|
2013-12-13 13:04:35 +01:00
|
|
|
|
|
|
|
struct BdrvTrackedRequest *waiting_for;
|
2013-06-24 17:13:10 +02:00
|
|
|
} BdrvTrackedRequest;
|
|
|
|
|
2004-08-01 23:59:26 +02:00
|
|
|
struct BlockDriver {
|
|
|
|
const char *format_name;
|
|
|
|
int instance_size;
|
2013-10-02 14:33:48 +02:00
|
|
|
|
2014-03-03 19:11:34 +01:00
|
|
|
/* set to true if the BlockDriver is a block filter */
|
|
|
|
bool is_filter;
|
|
|
|
/* for snapshots block filter like Quorum can implement the
|
|
|
|
* following recursive callback.
|
2014-01-23 21:31:36 +01:00
|
|
|
* It's purpose is to recurse on the filter children while calling
|
|
|
|
* bdrv_recurse_is_first_non_filter on them.
|
|
|
|
* For a sample implementation look in the future Quorum block filter.
|
2013-10-02 14:33:48 +02:00
|
|
|
*/
|
2014-01-23 21:31:36 +01:00
|
|
|
bool (*bdrv_recurse_is_first_non_filter)(BlockDriverState *bs,
|
|
|
|
BlockDriverState *candidate);
|
2013-10-02 14:33:48 +02:00
|
|
|
|
2004-08-01 23:59:26 +02:00
|
|
|
int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename);
|
2009-06-15 14:04:22 +02:00
|
|
|
int (*bdrv_probe_device)(const char *filename);
|
2013-03-18 16:40:51 +01:00
|
|
|
|
|
|
|
/* Any driver implementing this callback is expected to be able to handle
|
|
|
|
* NULL file names in its .bdrv_open() implementation */
|
2013-03-15 18:47:22 +01:00
|
|
|
void (*bdrv_parse_filename)(const char *filename, QDict *options, Error **errp);
|
2013-09-24 17:07:04 +02:00
|
|
|
/* Drivers not implementing bdrv_parse_filename nor bdrv_open should have
|
|
|
|
* this field set to true, except ones that are defined only by their
|
|
|
|
* child's bs.
|
|
|
|
* An example of the last type will be the quorum block driver.
|
|
|
|
*/
|
|
|
|
bool bdrv_needs_filename;
|
2012-09-20 21:13:19 +02:00
|
|
|
|
2014-06-04 15:09:35 +02:00
|
|
|
/* Set if a driver can support backing files */
|
|
|
|
bool supports_backing;
|
|
|
|
|
2012-09-20 21:13:19 +02:00
|
|
|
/* For handling image reopen for split or non-split files */
|
|
|
|
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);
|
|
|
|
|
2013-09-05 14:22:29 +02:00
|
|
|
int (*bdrv_open)(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp);
|
|
|
|
int (*bdrv_file_open)(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp);
|
2007-09-16 23:08:06 +02:00
|
|
|
int (*bdrv_read)(BlockDriverState *bs, int64_t sector_num,
|
2004-08-01 23:59:26 +02:00
|
|
|
uint8_t *buf, int nb_sectors);
|
2007-09-16 23:08:06 +02:00
|
|
|
int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num,
|
2004-08-01 23:59:26 +02:00
|
|
|
const uint8_t *buf, int nb_sectors);
|
2004-09-18 21:32:11 +02:00
|
|
|
void (*bdrv_close)(BlockDriverState *bs);
|
2012-05-08 16:51:41 +02:00
|
|
|
void (*bdrv_rebind)(BlockDriverState *bs);
|
2014-06-05 11:21:11 +02:00
|
|
|
int (*bdrv_create)(const char *filename, QemuOpts *opts, Error **errp);
|
2004-08-01 23:59:26 +02:00
|
|
|
int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
|
2005-12-18 19:28:15 +01:00
|
|
|
int (*bdrv_make_empty)(BlockDriverState *bs);
|
2014-07-18 20:24:56 +02:00
|
|
|
|
|
|
|
void (*bdrv_refresh_filename)(BlockDriverState *bs);
|
|
|
|
|
2006-08-01 18:21:11 +02:00
|
|
|
/* aio */
|
2014-10-07 13:59:14 +02:00
|
|
|
BlockAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs,
|
2009-04-07 20:43:24 +02:00
|
|
|
int64_t sector_num, QEMUIOVector *qiov, 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,
|
2009-04-07 20:43:24 +02:00
|
|
|
int64_t sector_num, QEMUIOVector *qiov, 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,
|
2011-10-17 12:32:14 +02:00
|
|
|
int64_t sector_num, int nb_sectors,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb, void *opaque);
|
2006-08-01 18:21:11 +02:00
|
|
|
|
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);
|
|
|
|
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. Typically an image format
|
|
|
|
* would use a compact metadata representation to implement this. This
|
|
|
|
* function pointer may be NULL and .bdrv_co_writev() will be called
|
|
|
|
* instead.
|
|
|
|
*/
|
|
|
|
int coroutine_fn (*bdrv_co_write_zeroes)(BlockDriverState *bs,
|
2013-10-24 12:06:51 +02:00
|
|
|
int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
|
2011-10-17 12:32:14 +02:00
|
|
|
int coroutine_fn (*bdrv_co_discard)(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors);
|
2013-09-04 19:00:28 +02:00
|
|
|
int64_t coroutine_fn (*bdrv_co_get_block_status)(BlockDriverState *bs,
|
2011-11-14 13:44:19 +01:00
|
|
|
int64_t sector_num, int nb_sectors, int *pnum);
|
2011-07-14 17:27:13 +02:00
|
|
|
|
2011-11-14 22:09:45 +01:00
|
|
|
/*
|
|
|
|
* Invalidate any cached meta-data.
|
|
|
|
*/
|
2014-03-12 15:59:16 +01:00
|
|
|
void (*bdrv_invalidate_cache)(BlockDriverState *bs, Error **errp);
|
2011-11-14 22:09:45 +01:00
|
|
|
|
2011-11-10 17:25:44 +01:00
|
|
|
/*
|
|
|
|
* Flushes all data that was already written to the OS all the way down to
|
|
|
|
* the disk (for example raw-posix calls fsync()).
|
|
|
|
*/
|
|
|
|
int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs);
|
|
|
|
|
2011-11-10 18:10:11 +01:00
|
|
|
/*
|
|
|
|
* Flushes all internal caches to the OS. The data may still sit in a
|
|
|
|
* writeback cache of the host OS, but it will survive a crash of the qemu
|
|
|
|
* process.
|
|
|
|
*/
|
|
|
|
int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs);
|
|
|
|
|
2006-08-01 18:21:11 +02:00
|
|
|
const char *protocol_name;
|
|
|
|
int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset);
|
block: Avoid unecessary drv->bdrv_getlength() calls
The block layer generally keeps the size of an image cached in
bs->total_sectors so that it doesn't have to perform expensive
operations to get the size whenever it needs it.
This doesn't work however when using a backend that can change its size
without qemu being aware of it, i.e. passthrough of removable media like
CD-ROMs or floppy disks. For this reason, the caching is disabled when a
removable device is used.
It is obvious that checking whether the _guest_ device has removable
media isn't the right thing to do when we want to know whether the size
of the host backend can change. To make things worse, non-top-level
BlockDriverStates never have any device attached, which makes qemu
assume they are removable, so drv->bdrv_getlength() is always called on
the protocol layer. In the case of raw-posix, this causes unnecessary
lseek() system calls, which turned out to be rather expensive.
This patch completely changes the logic and disables bs->total_sectors
caching only for certain block driver types, for which a size change is
expected: host_cdrom and host_floppy on POSIX, host_device on win32; also
the raw format in case it sits on top of one of these protocols, but in
the common case the nested bdrv_getlength() call on the protocol driver
will use the cache again and avoid an expensive drv->bdrv_getlength()
call.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
2013-10-29 12:18:58 +01:00
|
|
|
|
2006-08-01 18:21:11 +02:00
|
|
|
int64_t (*bdrv_getlength)(BlockDriverState *bs);
|
block: Avoid unecessary drv->bdrv_getlength() calls
The block layer generally keeps the size of an image cached in
bs->total_sectors so that it doesn't have to perform expensive
operations to get the size whenever it needs it.
This doesn't work however when using a backend that can change its size
without qemu being aware of it, i.e. passthrough of removable media like
CD-ROMs or floppy disks. For this reason, the caching is disabled when a
removable device is used.
It is obvious that checking whether the _guest_ device has removable
media isn't the right thing to do when we want to know whether the size
of the host backend can change. To make things worse, non-top-level
BlockDriverStates never have any device attached, which makes qemu
assume they are removable, so drv->bdrv_getlength() is always called on
the protocol layer. In the case of raw-posix, this causes unnecessary
lseek() system calls, which turned out to be rather expensive.
This patch completely changes the logic and disables bs->total_sectors
caching only for certain block driver types, for which a size change is
expected: host_cdrom and host_floppy on POSIX, host_device on win32; also
the raw format in case it sits on top of one of these protocols, but in
the common case the nested bdrv_getlength() call on the protocol driver
will use the cache again and avoid an expensive drv->bdrv_getlength()
call.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
2013-10-29 12:18:58 +01:00
|
|
|
bool has_variable_length;
|
2011-07-12 13:56:39 +02:00
|
|
|
int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs);
|
block: Avoid unecessary drv->bdrv_getlength() calls
The block layer generally keeps the size of an image cached in
bs->total_sectors so that it doesn't have to perform expensive
operations to get the size whenever it needs it.
This doesn't work however when using a backend that can change its size
without qemu being aware of it, i.e. passthrough of removable media like
CD-ROMs or floppy disks. For this reason, the caching is disabled when a
removable device is used.
It is obvious that checking whether the _guest_ device has removable
media isn't the right thing to do when we want to know whether the size
of the host backend can change. To make things worse, non-top-level
BlockDriverStates never have any device attached, which makes qemu
assume they are removable, so drv->bdrv_getlength() is always called on
the protocol layer. In the case of raw-posix, this causes unnecessary
lseek() system calls, which turned out to be rather expensive.
This patch completely changes the logic and disables bs->total_sectors
caching only for certain block driver types, for which a size change is
expected: host_cdrom and host_floppy on POSIX, host_device on win32; also
the raw format in case it sits on top of one of these protocols, but in
the common case the nested bdrv_getlength() call on the protocol driver
will use the cache again and avoid an expensive drv->bdrv_getlength()
call.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
2013-10-29 12:18:58 +01:00
|
|
|
|
2007-09-16 23:08:06 +02:00
|
|
|
int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num,
|
2006-08-05 23:31:00 +02:00
|
|
|
const uint8_t *buf, int nb_sectors);
|
|
|
|
|
2007-09-16 23:08:06 +02:00
|
|
|
int (*bdrv_snapshot_create)(BlockDriverState *bs,
|
2006-08-05 23:31:00 +02:00
|
|
|
QEMUSnapshotInfo *sn_info);
|
2007-09-16 23:08:06 +02:00
|
|
|
int (*bdrv_snapshot_goto)(BlockDriverState *bs,
|
2006-08-05 23:31:00 +02:00
|
|
|
const char *snapshot_id);
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
int (*bdrv_snapshot_delete)(BlockDriverState *bs,
|
|
|
|
const char *snapshot_id,
|
|
|
|
const char *name,
|
|
|
|
Error **errp);
|
2007-09-16 23:08:06 +02:00
|
|
|
int (*bdrv_snapshot_list)(BlockDriverState *bs,
|
2006-08-05 23:31:00 +02:00
|
|
|
QEMUSnapshotInfo **psn_info);
|
2010-09-22 04:58:41 +02:00
|
|
|
int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs,
|
2013-12-04 10:10:54 +01:00
|
|
|
const char *snapshot_id,
|
|
|
|
const char *name,
|
|
|
|
Error **errp);
|
2006-08-05 23:31:00 +02:00
|
|
|
int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi);
|
2013-10-09 10:46:16 +02:00
|
|
|
ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs);
|
2006-08-01 18:21:11 +02:00
|
|
|
|
2013-04-05 21:27:53 +02:00
|
|
|
int (*bdrv_save_vmstate)(BlockDriverState *bs, QEMUIOVector *qiov,
|
|
|
|
int64_t pos);
|
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-01-12 12:55:17 +01:00
|
|
|
int (*bdrv_change_backing_file)(BlockDriverState *bs,
|
|
|
|
const char *backing_file, const char *backing_fmt);
|
|
|
|
|
2006-08-19 13:45:59 +02:00
|
|
|
/* removable device specific */
|
|
|
|
int (*bdrv_is_inserted)(BlockDriverState *bs);
|
|
|
|
int (*bdrv_media_changed)(BlockDriverState *bs);
|
2012-02-03 19:24:53 +01:00
|
|
|
void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag);
|
2011-09-06 18:58:47 +02:00
|
|
|
void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked);
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2007-12-24 17:10:43 +01:00
|
|
|
/* to control generic scsi devices */
|
|
|
|
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);
|
2007-12-24 17:10:43 +01:00
|
|
|
|
2009-05-18 16:42:10 +02:00
|
|
|
/* List of options for creating images, terminated by name == NULL */
|
2014-06-05 11:20:51 +02:00
|
|
|
QemuOptsList *create_opts;
|
2009-03-28 18:55:10 +01:00
|
|
|
|
2010-06-29 12:37:54 +02:00
|
|
|
/*
|
|
|
|
* Returns 0 for completed check, -errno for internal errors.
|
|
|
|
* The check results are stored in result.
|
|
|
|
*/
|
2012-05-11 16:07:02 +02:00
|
|
|
int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result,
|
|
|
|
BdrvCheckMode fix);
|
2009-04-22 01:11:50 +02:00
|
|
|
|
2014-10-27 11:12:50 +01:00
|
|
|
int (*bdrv_amend_options)(BlockDriverState *bs, QemuOpts *opts,
|
|
|
|
BlockDriverAmendStatusCB *status_cb);
|
2013-09-03 10:09:50 +02:00
|
|
|
|
2010-03-15 17:27:00 +01:00
|
|
|
void (*bdrv_debug_event)(BlockDriverState *bs, BlkDebugEvent event);
|
|
|
|
|
2012-12-06 14:32:58 +01:00
|
|
|
/* TODO Better pass a option string/QDict/QemuOpts to add any rule? */
|
|
|
|
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-07-16 17:48:16 +02:00
|
|
|
void (*bdrv_refresh_limits)(BlockDriverState *bs, Error **errp);
|
2013-12-11 19:26:16 +01:00
|
|
|
|
2010-07-28 11:26:29 +02:00
|
|
|
/*
|
|
|
|
* Returns 1 if newly created images are guaranteed to contain only
|
|
|
|
* zeros, 0 otherwise.
|
|
|
|
*/
|
|
|
|
int (*bdrv_has_zero_init)(BlockDriverState *bs);
|
2009-11-30 16:54:15 +01:00
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
/* Remove fd handlers, timers, and other event loop callbacks so the event
|
|
|
|
* loop is no longer in use. Called with no in-flight requests and in
|
|
|
|
* depth-first traversal order with parents before child nodes.
|
|
|
|
*/
|
|
|
|
void (*bdrv_detach_aio_context)(BlockDriverState *bs);
|
|
|
|
|
|
|
|
/* Add fd handlers, timers, and other event loop callbacks so I/O requests
|
|
|
|
* can be processed again. Called with no in-flight requests and in
|
|
|
|
* depth-first traversal order with child nodes before parent nodes.
|
|
|
|
*/
|
|
|
|
void (*bdrv_attach_aio_context)(BlockDriverState *bs,
|
|
|
|
AioContext *new_context);
|
|
|
|
|
2014-07-04 12:04:33 +02:00
|
|
|
/* io queue for linux-aio */
|
|
|
|
void (*bdrv_io_plug)(BlockDriverState *bs);
|
|
|
|
void (*bdrv_io_unplug)(BlockDriverState *bs);
|
|
|
|
void (*bdrv_flush_io_queue)(BlockDriverState *bs);
|
|
|
|
|
2010-04-13 11:29:33 +02:00
|
|
|
QLIST_ENTRY(BlockDriver) list;
|
2004-08-01 23:59:26 +02:00
|
|
|
};
|
|
|
|
|
2013-10-24 12:06:56 +02:00
|
|
|
typedef struct BlockLimits {
|
|
|
|
/* maximum number of sectors that can be discarded at once */
|
|
|
|
int max_discard;
|
|
|
|
|
|
|
|
/* optimal alignment for discard requests in sectors */
|
|
|
|
int64_t discard_alignment;
|
|
|
|
|
|
|
|
/* maximum number of sectors that can zeroized at once */
|
|
|
|
int max_write_zeroes;
|
|
|
|
|
|
|
|
/* optimal alignment for write zeroes requests in sectors */
|
|
|
|
int64_t write_zeroes_alignment;
|
2013-11-27 11:07:04 +01:00
|
|
|
|
|
|
|
/* optimal transfer length in sectors */
|
|
|
|
int opt_transfer_length;
|
2013-11-28 10:23:32 +01:00
|
|
|
|
2014-10-27 10:18:44 +01:00
|
|
|
/* maximal transfer length in sectors */
|
|
|
|
int max_transfer_length;
|
|
|
|
|
2013-11-28 10:23:32 +01:00
|
|
|
/* memory alignment so that no bounce buffer is needed */
|
|
|
|
size_t opt_mem_alignment;
|
2013-10-24 12:06:56 +02:00
|
|
|
} BlockLimits;
|
|
|
|
|
2014-05-23 15:29:42 +02:00
|
|
|
typedef struct BdrvOpBlocker BdrvOpBlocker;
|
|
|
|
|
2014-06-20 21:57:33 +02:00
|
|
|
typedef struct BdrvAioNotifier {
|
|
|
|
void (*attached_aio_context)(AioContext *new_context, void *opaque);
|
|
|
|
void (*detach_aio_context)(void *opaque);
|
|
|
|
|
|
|
|
void *opaque;
|
|
|
|
|
|
|
|
QLIST_ENTRY(BdrvAioNotifier) list;
|
|
|
|
} BdrvAioNotifier;
|
|
|
|
|
2012-02-28 21:54:06 +01:00
|
|
|
/*
|
|
|
|
* Note: the function bdrv_append() copies and swaps contents of
|
|
|
|
* BlockDriverStates, so if you add new fields to this struct, please
|
|
|
|
* inspect bdrv_append() to determine if the new fields need to be
|
|
|
|
* copied as well.
|
|
|
|
*/
|
2004-08-01 23:59:26 +02:00
|
|
|
struct BlockDriverState {
|
2006-08-06 15:35:09 +02:00
|
|
|
int64_t total_sectors; /* if we are reading a disk image, give its
|
|
|
|
size in sectors */
|
2004-08-01 23:59:26 +02:00
|
|
|
int read_only; /* if true, the media is read only */
|
2010-02-14 12:39:18 +01:00
|
|
|
int open_flags; /* flags used to open the file, re-used for re-open */
|
2004-08-01 23:59:26 +02:00
|
|
|
int encrypted; /* if true, the media is encrypted */
|
2009-03-06 00:01:01 +01:00
|
|
|
int valid_key; /* if true, a valid encryption key has been set */
|
2007-12-24 17:10:43 +01:00
|
|
|
int sg; /* if true, the device is a /dev/sg* */
|
2011-11-28 17:08:47 +01:00
|
|
|
int copy_on_read; /* if true, copy read backing sectors into image
|
|
|
|
note this is a reference count */
|
raw: Prohibit dangerous writes for probed images
If the user neglects to specify the image format, QEMU probes the
image to guess it automatically, for convenience.
Relying on format probing is insecure for raw images (CVE-2008-2004).
If the guest writes a suitable header to the device, the next probe
will recognize a format chosen by the guest. A malicious guest can
abuse this to gain access to host files, e.g. by crafting a QCOW2
header with backing file /etc/shadow.
Commit 1e72d3b (April 2008) provided -drive parameter format to let
users disable probing. Commit f965509 (March 2009) extended QCOW2 to
optionally store the backing file format, to let users disable backing
file probing. QED has had a flag to suppress probing since the
beginning (2010), set whenever a raw backing file is assigned.
All of these additions that allow to avoid format probing have to be
specified explicitly. The default still allows the attack.
In order to fix this, commit 79368c8 (July 2010) put probed raw images
in a restricted mode, in which they wouldn't be able to overwrite the
first few bytes of the image so that they would identify as a different
image. If a write to the first sector would write one of the signatures
of another driver, qemu would instead zero out the first four bytes.
This patch was later reverted in commit 8b33d9e (September 2010) because
it didn't get the handling of unaligned qiov members right.
Today's block layer that is based on coroutines and has qiov utility
functions makes it much easier to get this functionality right, so this
patch implements it.
The other differences of this patch to the old one are that it doesn't
silently write something different than the guest requested by zeroing
out some bytes (it fails the request instead) and that it doesn't
maintain a list of signatures in the raw driver (it calls the usual
probe function instead).
Note that this change doesn't introduce new breakage for false positive
cases where the guest legitimately writes data into the first sector
that matches the signatures of an image format (e.g. for nested virt):
These cases were broken before, only the failure mode changes from
corruption after the next restart (when the wrong format is probed) to
failing the problematic write request.
Also note that like in the original patch, the restrictions only apply
if the image format has been guessed by probing. Explicitly specifying a
format allows guests to write anything they like.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1416497234-29880-8-git-send-email-kwolf@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-11-20 16:27:12 +01:00
|
|
|
bool probed;
|
2004-08-01 23:59:26 +02:00
|
|
|
|
2006-08-19 13:45:59 +02:00
|
|
|
BlockDriver *drv; /* NULL means no media */
|
2004-08-01 23:59:26 +02:00
|
|
|
void *opaque;
|
|
|
|
|
2014-10-07 13:59:05 +02:00
|
|
|
BlockBackend *blk; /* owning backend, if any */
|
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
AioContext *aio_context; /* event loop used for fd handlers, timers, etc */
|
2014-06-20 21:57:33 +02:00
|
|
|
/* long-running tasks intended to always use the same AioContext as this
|
|
|
|
* BDS may register themselves in this list to be notified of changes
|
|
|
|
* regarding this BDS's context */
|
|
|
|
QLIST_HEAD(, BdrvAioNotifier) aio_notifiers;
|
2014-05-08 16:34:37 +02:00
|
|
|
|
2015-01-22 14:03:30 +01:00
|
|
|
char filename[PATH_MAX];
|
|
|
|
char backing_file[PATH_MAX]; /* if non zero, the image is a diff of
|
|
|
|
this file image */
|
2009-03-28 18:55:10 +01:00
|
|
|
char backing_format[16]; /* if non-zero and backing_file exists */
|
2006-08-19 13:45:59 +02:00
|
|
|
|
2014-07-18 20:24:56 +02:00
|
|
|
QDict *full_open_options;
|
2015-01-22 14:03:30 +01:00
|
|
|
char exact_filename[PATH_MAX];
|
2014-07-18 20:24:56 +02:00
|
|
|
|
2004-08-01 23:59:26 +02:00
|
|
|
BlockDriverState *backing_hd;
|
2010-04-14 14:17:38 +02:00
|
|
|
BlockDriverState *file;
|
|
|
|
|
2012-08-23 11:20:36 +02:00
|
|
|
NotifierList close_notifiers;
|
|
|
|
|
2013-06-24 17:13:10 +02:00
|
|
|
/* Callback before write request is processed */
|
|
|
|
NotifierWithReturnList before_write_notifiers;
|
|
|
|
|
2013-12-04 16:43:44 +01:00
|
|
|
/* number of in-flight serialising requests */
|
|
|
|
unsigned int serialising_in_flight;
|
2012-01-18 15:40:42 +01:00
|
|
|
|
2013-09-02 14:14:39 +02:00
|
|
|
/* I/O throttling */
|
|
|
|
ThrottleState throttle_state;
|
|
|
|
CoQueue throttled_reqs[2];
|
2011-11-03 09:57:25 +01:00
|
|
|
bool io_limits_enabled;
|
|
|
|
|
2007-12-02 06:18:19 +01:00
|
|
|
/* I/O stats (display with "info blockstats"). */
|
2014-09-05 15:46:15 +02:00
|
|
|
BlockAcctStats stats;
|
2007-12-02 06:18:19 +01:00
|
|
|
|
2013-10-24 12:06:56 +02:00
|
|
|
/* I/O Limits */
|
|
|
|
BlockLimits bl;
|
|
|
|
|
2009-03-03 18:37:16 +01:00
|
|
|
/* Whether the disk can expand beyond total_sectors */
|
|
|
|
int growable;
|
|
|
|
|
2013-08-22 09:24:14 +02:00
|
|
|
/* Whether produces zeros when read beyond eof */
|
|
|
|
bool zero_beyond_eof;
|
|
|
|
|
2011-11-29 12:42:20 +01:00
|
|
|
/* Alignment requirement for offset/length of I/O requests */
|
|
|
|
unsigned int request_alignment;
|
|
|
|
|
2011-11-29 11:35:47 +01:00
|
|
|
/* the block size for which the guest device expects atomicity */
|
|
|
|
int guest_block_size;
|
2009-04-22 22:20:00 +02:00
|
|
|
|
2009-09-04 19:01:15 +02:00
|
|
|
/* do we need to tell the quest if we have a volatile write cache? */
|
|
|
|
int enable_write_cache;
|
|
|
|
|
2004-08-01 23:59:26 +02:00
|
|
|
/* NOTE: the following infos are only hints for real hardware
|
|
|
|
drivers. They are not used by the block driver */
|
2012-09-28 17:22:54 +02:00
|
|
|
BlockdevOnError on_read_error, on_write_error;
|
2011-10-14 22:11:23 +02:00
|
|
|
bool iostatus_enabled;
|
2011-09-21 22:16:47 +02:00
|
|
|
BlockDeviceIoStatus iostatus;
|
2014-01-23 21:31:32 +01:00
|
|
|
|
|
|
|
/* the following member gives a name to every node on the bs graph. */
|
|
|
|
char node_name[32];
|
|
|
|
/* element of the list of named nodes building the graph */
|
|
|
|
QTAILQ_ENTRY(BlockDriverState) node_list;
|
|
|
|
/* element of the list of "drives" the guest sees */
|
|
|
|
QTAILQ_ENTRY(BlockDriverState) device_list;
|
2013-11-13 11:29:43 +01:00
|
|
|
QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps;
|
2013-08-23 03:14:46 +02:00
|
|
|
int refcnt;
|
2011-11-17 14:40:27 +01:00
|
|
|
|
|
|
|
QLIST_HEAD(, BdrvTrackedRequest) tracked_requests;
|
2012-01-18 15:40:43 +01:00
|
|
|
|
2014-05-23 15:29:42 +02:00
|
|
|
/* operation blockers */
|
|
|
|
QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX];
|
|
|
|
|
2012-01-18 15:40:43 +01:00
|
|
|
/* long-running background operation */
|
|
|
|
BlockJob *job;
|
2012-09-20 21:13:19 +02:00
|
|
|
|
2013-03-15 10:35:02 +01:00
|
|
|
QDict *options;
|
2014-05-18 00:58:19 +02:00
|
|
|
BlockdevDetectZeroesOptions detect_zeroes;
|
2014-05-23 15:29:47 +02:00
|
|
|
|
|
|
|
/* The error object in use for blocking operations on backing_hd */
|
|
|
|
Error *backing_blocker;
|
2004-08-01 23:59:26 +02:00
|
|
|
};
|
|
|
|
|
2014-12-02 18:32:41 +01:00
|
|
|
|
|
|
|
/* Essential block drivers which must always be statically linked into qemu, and
|
|
|
|
* which therefore can be accessed without using bdrv_find_format() */
|
|
|
|
extern BlockDriver bdrv_file;
|
|
|
|
extern BlockDriver bdrv_raw;
|
|
|
|
extern BlockDriver bdrv_qcow2;
|
|
|
|
|
|
|
|
|
2012-05-28 09:27:54 +02:00
|
|
|
int get_tmp_filename(char *filename, int size);
|
raw: Prohibit dangerous writes for probed images
If the user neglects to specify the image format, QEMU probes the
image to guess it automatically, for convenience.
Relying on format probing is insecure for raw images (CVE-2008-2004).
If the guest writes a suitable header to the device, the next probe
will recognize a format chosen by the guest. A malicious guest can
abuse this to gain access to host files, e.g. by crafting a QCOW2
header with backing file /etc/shadow.
Commit 1e72d3b (April 2008) provided -drive parameter format to let
users disable probing. Commit f965509 (March 2009) extended QCOW2 to
optionally store the backing file format, to let users disable backing
file probing. QED has had a flag to suppress probing since the
beginning (2010), set whenever a raw backing file is assigned.
All of these additions that allow to avoid format probing have to be
specified explicitly. The default still allows the attack.
In order to fix this, commit 79368c8 (July 2010) put probed raw images
in a restricted mode, in which they wouldn't be able to overwrite the
first few bytes of the image so that they would identify as a different
image. If a write to the first sector would write one of the signatures
of another driver, qemu would instead zero out the first four bytes.
This patch was later reverted in commit 8b33d9e (September 2010) because
it didn't get the handling of unaligned qiov members right.
Today's block layer that is based on coroutines and has qiov utility
functions makes it much easier to get this functionality right, so this
patch implements it.
The other differences of this patch to the old one are that it doesn't
silently write something different than the guest requested by zeroing
out some bytes (it fails the request instead) and that it doesn't
maintain a list of signatures in the raw driver (it calls the usual
probe function instead).
Note that this change doesn't introduce new breakage for false positive
cases where the guest legitimately writes data into the first sector
that matches the signatures of an image format (e.g. for nested virt):
These cases were broken before, only the failure mode changes from
corruption after the next restart (when the wrong format is probed) to
failing the problematic write request.
Also note that like in the original patch, the restrictions only apply
if the image format has been guessed by probing. Explicitly specifying a
format allows guests to write anything they like.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1416497234-29880-8-git-send-email-kwolf@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2014-11-20 16:27:12 +01:00
|
|
|
BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
|
|
|
|
const char *filename);
|
2005-12-18 19:28:15 +01:00
|
|
|
|
2011-11-03 09:57:25 +01:00
|
|
|
void bdrv_set_io_limits(BlockDriverState *bs,
|
2013-09-02 14:14:39 +02:00
|
|
|
ThrottleConfig *cfg);
|
|
|
|
|
2011-11-03 09:57:25 +01:00
|
|
|
|
2013-06-24 17:13:10 +02:00
|
|
|
/**
|
|
|
|
* bdrv_add_before_write_notifier:
|
|
|
|
*
|
|
|
|
* Register a callback that is invoked before write requests are processed but
|
|
|
|
* after any throttling or waiting for overlapping requests.
|
|
|
|
*/
|
|
|
|
void bdrv_add_before_write_notifier(BlockDriverState *bs,
|
|
|
|
NotifierWithReturn *notifier);
|
|
|
|
|
2014-05-08 16:34:37 +02:00
|
|
|
/**
|
|
|
|
* bdrv_detach_aio_context:
|
|
|
|
*
|
|
|
|
* May be called from .bdrv_detach_aio_context() to detach children from the
|
|
|
|
* current #AioContext. This is only needed by block drivers that manage their
|
|
|
|
* own children. Both ->file and ->backing_hd are automatically handled and
|
|
|
|
* block drivers should not call this function on them explicitly.
|
|
|
|
*/
|
|
|
|
void bdrv_detach_aio_context(BlockDriverState *bs);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* bdrv_attach_aio_context:
|
|
|
|
*
|
|
|
|
* May be called from .bdrv_attach_aio_context() to attach children to the new
|
|
|
|
* #AioContext. This is only needed by block drivers that manage their own
|
|
|
|
* children. Both ->file and ->backing_hd are automatically handled and block
|
|
|
|
* drivers should not call this function on them explicitly.
|
|
|
|
*/
|
|
|
|
void bdrv_attach_aio_context(BlockDriverState *bs,
|
|
|
|
AioContext *new_context);
|
|
|
|
|
2014-06-20 21:57:33 +02:00
|
|
|
/**
|
|
|
|
* bdrv_add_aio_context_notifier:
|
|
|
|
*
|
|
|
|
* If a long-running job intends to be always run in the same AioContext as a
|
|
|
|
* certain BDS, it may use this function to be notified of changes regarding the
|
|
|
|
* association of the BDS to an AioContext.
|
|
|
|
*
|
|
|
|
* attached_aio_context() is called after the target BDS has been attached to a
|
|
|
|
* new AioContext; detach_aio_context() is called before the target BDS is being
|
|
|
|
* detached from its old AioContext.
|
|
|
|
*/
|
|
|
|
void bdrv_add_aio_context_notifier(BlockDriverState *bs,
|
|
|
|
void (*attached_aio_context)(AioContext *new_context, void *opaque),
|
|
|
|
void (*detach_aio_context)(void *opaque), void *opaque);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* bdrv_remove_aio_context_notifier:
|
|
|
|
*
|
|
|
|
* Unsubscribe of change notifications regarding the BDS's AioContext. The
|
|
|
|
* parameters given here have to be the same as those given to
|
|
|
|
* bdrv_add_aio_context_notifier().
|
|
|
|
*/
|
|
|
|
void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
|
|
|
|
void (*aio_context_attached)(AioContext *,
|
|
|
|
void *),
|
|
|
|
void (*aio_context_detached)(void *),
|
|
|
|
void *opaque);
|
|
|
|
|
2009-06-15 14:04:22 +02:00
|
|
|
#ifdef _WIN32
|
|
|
|
int is_windows_drive(const char *filename);
|
|
|
|
#endif
|
|
|
|
|
2012-03-30 13:17:13 +02:00
|
|
|
/**
|
|
|
|
* stream_start:
|
|
|
|
* @bs: Block device to operate on.
|
|
|
|
* @base: Block device that will become the new base, or %NULL to
|
|
|
|
* flatten the whole backing file chain onto @bs.
|
|
|
|
* @base_id: The file name that will be written to @bs as the new
|
|
|
|
* backing file if the job completes. Ignored if @base is %NULL.
|
2012-04-25 17:51:03 +02:00
|
|
|
* @speed: The maximum speed, in bytes per second, or 0 for unlimited.
|
2012-09-28 17:22:59 +02:00
|
|
|
* @on_error: The action to take upon error.
|
2012-03-30 13:17:13 +02:00
|
|
|
* @cb: Completion function for the job.
|
|
|
|
* @opaque: Opaque pointer value passed to @cb.
|
2012-04-25 17:51:00 +02:00
|
|
|
* @errp: Error object.
|
2012-03-30 13:17:13 +02:00
|
|
|
*
|
|
|
|
* Start a streaming operation on @bs. Clusters that are unallocated
|
|
|
|
* in @bs, but allocated in any image between @base and @bs (both
|
|
|
|
* exclusive) will be written to @bs. At the end of a successful
|
|
|
|
* streaming job, the backing file of @bs will be changed to
|
|
|
|
* @base_id in the written image and to @base in the live BlockDriverState.
|
|
|
|
*/
|
2012-04-25 17:51:00 +02:00
|
|
|
void stream_start(BlockDriverState *bs, BlockDriverState *base,
|
2012-09-28 17:22:59 +02:00
|
|
|
const char *base_id, int64_t speed, BlockdevOnError on_error,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb,
|
2012-04-25 17:51:00 +02:00
|
|
|
void *opaque, Error **errp);
|
2012-01-18 15:40:44 +01:00
|
|
|
|
2012-09-27 19:29:13 +02:00
|
|
|
/**
|
|
|
|
* commit_start:
|
2013-12-16 07:45:30 +01:00
|
|
|
* @bs: Active block device.
|
|
|
|
* @top: Top block device to be committed.
|
|
|
|
* @base: Block device that will be written into, and become the new top.
|
2012-09-27 19:29:13 +02:00
|
|
|
* @speed: The maximum speed, in bytes per second, or 0 for unlimited.
|
|
|
|
* @on_error: The action to take upon error.
|
|
|
|
* @cb: Completion function for the job.
|
|
|
|
* @opaque: Opaque pointer value passed to @cb.
|
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
|
|
|
* @backing_file_str: String to use as the backing file in @top's overlay
|
2012-09-27 19:29:13 +02:00
|
|
|
* @errp: Error object.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void commit_start(BlockDriverState *bs, BlockDriverState *base,
|
|
|
|
BlockDriverState *top, int64_t speed,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockdevOnError on_error, BlockCompletionFunc *cb,
|
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
|
|
|
void *opaque, const char *backing_file_str, Error **errp);
|
2013-12-16 07:45:30 +01:00
|
|
|
/**
|
|
|
|
* commit_active_start:
|
|
|
|
* @bs: Active block device to be committed.
|
|
|
|
* @base: Block device that will be written into, and become the new top.
|
|
|
|
* @speed: The maximum speed, in bytes per second, or 0 for unlimited.
|
|
|
|
* @on_error: The action to take upon error.
|
|
|
|
* @cb: Completion function for the job.
|
|
|
|
* @opaque: Opaque pointer value passed to @cb.
|
|
|
|
* @errp: Error object.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void commit_active_start(BlockDriverState *bs, BlockDriverState *base,
|
|
|
|
int64_t speed,
|
|
|
|
BlockdevOnError on_error,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb,
|
2013-12-16 07:45:30 +01:00
|
|
|
void *opaque, Error **errp);
|
2012-10-18 16:49:23 +02:00
|
|
|
/*
|
|
|
|
* mirror_start:
|
|
|
|
* @bs: Block device to operate on.
|
|
|
|
* @target: Block device to write to.
|
2014-06-27 18:25:25 +02:00
|
|
|
* @replaces: Block graph node name to replace once the mirror is done. Can
|
|
|
|
* only be used when full mirroring is selected.
|
2012-10-18 16:49:23 +02:00
|
|
|
* @speed: The maximum speed, in bytes per second, or 0 for unlimited.
|
2013-01-21 17:09:46 +01:00
|
|
|
* @granularity: The chosen granularity for the dirty bitmap.
|
2013-01-22 09:03:13 +01:00
|
|
|
* @buf_size: The amount of data that can be in flight at one time.
|
2012-10-18 16:49:23 +02:00
|
|
|
* @mode: Whether to collapse all images in the chain to the target.
|
2012-10-18 16:49:28 +02:00
|
|
|
* @on_source_error: The action to take upon error reading from the source.
|
|
|
|
* @on_target_error: The action to take upon error writing to the target.
|
2012-10-18 16:49:23 +02:00
|
|
|
* @cb: Completion function for the job.
|
|
|
|
* @opaque: Opaque pointer value passed to @cb.
|
|
|
|
* @errp: Error object.
|
|
|
|
*
|
|
|
|
* Start a mirroring operation on @bs. Clusters that are allocated
|
|
|
|
* in @bs will be written to @bs until the job is cancelled or
|
|
|
|
* manually completed. At the end of a successful mirroring job,
|
|
|
|
* @bs will be switched to read from @target.
|
|
|
|
*/
|
|
|
|
void mirror_start(BlockDriverState *bs, BlockDriverState *target,
|
2014-06-27 18:25:25 +02:00
|
|
|
const char *replaces,
|
2013-01-22 09:03:13 +01:00
|
|
|
int64_t speed, int64_t granularity, int64_t buf_size,
|
|
|
|
MirrorSyncMode mode, BlockdevOnError on_source_error,
|
2012-10-18 16:49:28 +02:00
|
|
|
BlockdevOnError on_target_error,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb,
|
2012-10-18 16:49:23 +02:00
|
|
|
void *opaque, Error **errp);
|
|
|
|
|
2013-06-24 17:13:11 +02:00
|
|
|
/*
|
|
|
|
* backup_start:
|
|
|
|
* @bs: Block device to operate on.
|
|
|
|
* @target: Block device to write to.
|
|
|
|
* @speed: The maximum speed, in bytes per second, or 0 for unlimited.
|
2013-07-26 20:39:04 +02:00
|
|
|
* @sync_mode: What parts of the disk image should be copied to the destination.
|
2013-06-24 17:13:11 +02:00
|
|
|
* @on_source_error: The action to take upon error reading from the source.
|
|
|
|
* @on_target_error: The action to take upon error writing to the target.
|
|
|
|
* @cb: Completion function for the job.
|
|
|
|
* @opaque: Opaque pointer value passed to @cb.
|
|
|
|
*
|
|
|
|
* Start a backup operation on @bs. Clusters in @bs are written to @target
|
|
|
|
* until the job is cancelled or manually completed.
|
|
|
|
*/
|
|
|
|
void backup_start(BlockDriverState *bs, BlockDriverState *target,
|
2013-07-26 20:39:04 +02:00
|
|
|
int64_t speed, MirrorSyncMode sync_mode,
|
|
|
|
BlockdevOnError on_source_error,
|
2013-06-24 17:13:11 +02:00
|
|
|
BlockdevOnError on_target_error,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockCompletionFunc *cb, void *opaque,
|
2013-06-24 17:13:11 +02:00
|
|
|
Error **errp);
|
|
|
|
|
2014-10-07 13:59:25 +02:00
|
|
|
void blk_dev_change_media_cb(BlockBackend *blk, bool load);
|
|
|
|
bool blk_dev_has_removable_media(BlockBackend *blk);
|
|
|
|
void blk_dev_eject_request(BlockBackend *blk, bool force);
|
|
|
|
bool blk_dev_is_tray_open(BlockBackend *blk);
|
|
|
|
bool blk_dev_is_medium_locked(BlockBackend *blk);
|
|
|
|
void blk_dev_resize_cb(BlockBackend *blk);
|
|
|
|
|
2004-08-01 23:59:26 +02:00
|
|
|
#endif /* BLOCK_INT_H */
|