Block layer patches:
- file-posix: Make auto-read-only dynamic - Add x-blockdev-reopen QMP command - Finalize block-latency-histogram QMP command - gluster: Build fixes for newer lib version -----BEGIN PGP SIGNATURE----- iQIcBAABAgAGBQJciAjXAAoJEH8JsnLIjy/WwMcP/3VawpEBO4I94gp7KNUO1yZa rW7Rk0VO0gcvjk4fyTpQ1I3U2dfX6NwZLFMrk4oUS382QcKL9ky/TXVeeCaWxYxi 51OH6+wHQKu1MuAjM9acXRD59pfOwmI6wbKAgrungeFzHF3TvCYcLD0rY9Mhz1wp Q7Oqkk2au6cFrmqZChCF2S5guZc0JOuwzd+LdDshRNDek2Px8a3etVq37VBUuxzK WDvIws1IZkFI5y2WE3T8kn7YJ8NgMZ1p47tgkymDX7fkn3V766tec8ZYBy1Qz9ab +I3UlzijuXB8vq+egEtzQfJvvTyoPrb65VFjW94ITu9onuclYo1oV5XVgx2c/NiR WnUagbu9nft1E4+zmSrVB3Y4I7Pbwi+At/2L2dMQXIrrebK50Cqg8GW2fthhq/KM 5NavsqgdH14gOGS1yUGu06J0HO87XiJUKta4Th9M6iKvcGJqZ+F1WZGSiVEhhk1W w0FSmWdB/XdUwWoWdQnfx8d43OK34Q3spqsAe59DvKKyORw8Uug1i43yWvSepwSf SILmRYLOpMIrKUihh9NPIxB6QCzv/Mt7WjSEtaif+EXgQIGZhoQBjWpde0h5Dwh5 DrVz6NqDNnz0VDARPq2hgWOs4RlNpMvx5eZFJcK66RsOfLom3CL7mpnVaa+jd6e6 Nf0HPh/ubFB0IeEYbV0n =dQt+ -----END PGP SIGNATURE----- Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging Block layer patches: - file-posix: Make auto-read-only dynamic - Add x-blockdev-reopen QMP command - Finalize block-latency-histogram QMP command - gluster: Build fixes for newer lib version # gpg: Signature made Tue 12 Mar 2019 19:30:31 GMT # gpg: using RSA key 7F09B272C88F2FD6 # gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>" [full] # Primary key fingerprint: DC3D EB15 9A9A F95D 3D74 56FE 7F09 B272 C88F 2FD6 * remotes/kevin/tags/for-upstream: (28 commits) qemu-iotests: Test the x-blockdev-reopen QMP command block: Add an 'x-blockdev-reopen' QMP command block: Remove the AioContext parameter from bdrv_reopen_multiple() block: Add bdrv_reset_options_allowed() block: Add a 'mutable_opts' field to BlockDriver block: Allow changing the backing file on reopen block: Allow omitting the 'backing' option in certain cases block: Handle child references in bdrv_reopen_queue() block: Add 'keep_old_opts' parameter to bdrv_reopen_queue() block: Freeze the backing chain for the duration of the stream job block: Freeze the backing chain for the duration of the mirror job block: Freeze the backing chain for the duration of the commit job block: Allow freezing BdrvChild links nvme: fix write zeroes offset and count file-posix: Make auto-read-only dynamic file-posix: Prepare permission code for fd switching file-posix: Lock new fd in raw_reopen_prepare() file-posix: Store BDRVRawState.reopen_state during reopen file-posix: Factor out raw_reconfigure_getfd() file-posix: Fix bdrv_open_flags() for snapshot=on ... Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell
commit
36fe770966
440
block.c
440
block.c
@ -1163,13 +1163,6 @@ static int bdrv_open_flags(BlockDriverState *bs, int flags)
|
||||
*/
|
||||
open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
|
||||
|
||||
/*
|
||||
* Snapshots should be writable.
|
||||
*/
|
||||
if (flags & BDRV_O_TEMPORARY) {
|
||||
open_flags |= BDRV_O_RDWR;
|
||||
}
|
||||
|
||||
return open_flags;
|
||||
}
|
||||
|
||||
@ -1698,6 +1691,7 @@ static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);
|
||||
|
||||
typedef struct BlockReopenQueueEntry {
|
||||
bool prepared;
|
||||
bool perms_checked;
|
||||
BDRVReopenState state;
|
||||
QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
|
||||
} BlockReopenQueueEntry;
|
||||
@ -2132,6 +2126,8 @@ static void bdrv_replace_child_noperm(BdrvChild *child,
|
||||
BlockDriverState *old_bs = child->bs;
|
||||
int i;
|
||||
|
||||
assert(!child->frozen);
|
||||
|
||||
if (old_bs && new_bs) {
|
||||
assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
|
||||
}
|
||||
@ -2348,6 +2344,10 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
|
||||
bool update_inherits_from = bdrv_chain_contains(bs, backing_hd) &&
|
||||
bdrv_inherits_from_recursive(backing_hd, bs);
|
||||
|
||||
if (bdrv_is_backing_chain_frozen(bs, backing_bs(bs), errp)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (backing_hd) {
|
||||
bdrv_ref(backing_hd);
|
||||
}
|
||||
@ -2983,6 +2983,74 @@ BlockDriverState *bdrv_open(const char *filename, const char *reference,
|
||||
NULL, errp);
|
||||
}
|
||||
|
||||
/* Return true if the NULL-terminated @list contains @str */
|
||||
static bool is_str_in_list(const char *str, const char *const *list)
|
||||
{
|
||||
if (str && list) {
|
||||
int i;
|
||||
for (i = 0; list[i] != NULL; i++) {
|
||||
if (!strcmp(str, list[i])) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check that every option set in @bs->options is also set in
|
||||
* @new_opts.
|
||||
*
|
||||
* Options listed in the common_options list and in
|
||||
* @bs->drv->mutable_opts are skipped.
|
||||
*
|
||||
* Return 0 on success, otherwise return -EINVAL and set @errp.
|
||||
*/
|
||||
static int bdrv_reset_options_allowed(BlockDriverState *bs,
|
||||
const QDict *new_opts, Error **errp)
|
||||
{
|
||||
const QDictEntry *e;
|
||||
/* These options are common to all block drivers and are handled
|
||||
* in bdrv_reopen_prepare() so they can be left out of @new_opts */
|
||||
const char *const common_options[] = {
|
||||
"node-name", "discard", "cache.direct", "cache.no-flush",
|
||||
"read-only", "auto-read-only", "detect-zeroes", NULL
|
||||
};
|
||||
|
||||
for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {
|
||||
if (!qdict_haskey(new_opts, e->key) &&
|
||||
!is_str_in_list(e->key, common_options) &&
|
||||
!is_str_in_list(e->key, bs->drv->mutable_opts)) {
|
||||
error_setg(errp, "Option '%s' cannot be reset "
|
||||
"to its default value", e->key);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns true if @child can be reached recursively from @bs
|
||||
*/
|
||||
static bool bdrv_recurse_has_child(BlockDriverState *bs,
|
||||
BlockDriverState *child)
|
||||
{
|
||||
BdrvChild *c;
|
||||
|
||||
if (bs == child) {
|
||||
return true;
|
||||
}
|
||||
|
||||
QLIST_FOREACH(c, &bs->children, next) {
|
||||
if (bdrv_recurse_has_child(c->bs, child)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Adds a BlockDriverState to a simple queue for an atomic, transactional
|
||||
* reopen of multiple devices.
|
||||
@ -3010,7 +3078,8 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
|
||||
QDict *options,
|
||||
const BdrvChildRole *role,
|
||||
QDict *parent_options,
|
||||
int parent_flags)
|
||||
int parent_flags,
|
||||
bool keep_old_opts)
|
||||
{
|
||||
assert(bs != NULL);
|
||||
|
||||
@ -3050,13 +3119,13 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
|
||||
*/
|
||||
|
||||
/* Old explicitly set values (don't overwrite by inherited value) */
|
||||
if (bs_entry) {
|
||||
old_options = qdict_clone_shallow(bs_entry->state.explicit_options);
|
||||
} else {
|
||||
old_options = qdict_clone_shallow(bs->explicit_options);
|
||||
if (bs_entry || keep_old_opts) {
|
||||
old_options = qdict_clone_shallow(bs_entry ?
|
||||
bs_entry->state.explicit_options :
|
||||
bs->explicit_options);
|
||||
bdrv_join_options(bs, options, old_options);
|
||||
qobject_unref(old_options);
|
||||
}
|
||||
bdrv_join_options(bs, options, old_options);
|
||||
qobject_unref(old_options);
|
||||
|
||||
explicit_options = qdict_clone_shallow(options);
|
||||
|
||||
@ -3068,10 +3137,12 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
|
||||
flags = bdrv_get_flags(bs);
|
||||
}
|
||||
|
||||
/* Old values are used for options that aren't set yet */
|
||||
old_options = qdict_clone_shallow(bs->options);
|
||||
bdrv_join_options(bs, options, old_options);
|
||||
qobject_unref(old_options);
|
||||
if (keep_old_opts) {
|
||||
/* Old values are used for options that aren't set yet */
|
||||
old_options = qdict_clone_shallow(bs->options);
|
||||
bdrv_join_options(bs, options, old_options);
|
||||
qobject_unref(old_options);
|
||||
}
|
||||
|
||||
/* We have the final set of options so let's update the flags */
|
||||
options_copy = qdict_clone_shallow(options);
|
||||
@ -3104,9 +3175,21 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
|
||||
bs_entry->state.perm = UINT64_MAX;
|
||||
bs_entry->state.shared_perm = 0;
|
||||
|
||||
/*
|
||||
* If keep_old_opts is false then it means that unspecified
|
||||
* options must be reset to their original value. We don't allow
|
||||
* resetting 'backing' but we need to know if the option is
|
||||
* missing in order to decide if we have to return an error.
|
||||
*/
|
||||
if (!keep_old_opts) {
|
||||
bs_entry->state.backing_missing =
|
||||
!qdict_haskey(options, "backing") &&
|
||||
!qdict_haskey(options, "backing.driver");
|
||||
}
|
||||
|
||||
QLIST_FOREACH(child, &bs->children, next) {
|
||||
QDict *new_child_options;
|
||||
char *child_key_dot;
|
||||
QDict *new_child_options = NULL;
|
||||
bool child_keep_old = keep_old_opts;
|
||||
|
||||
/* reopen can only change the options of block devices that were
|
||||
* implicitly created and inherited options. For other (referenced)
|
||||
@ -3115,13 +3198,32 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
|
||||
continue;
|
||||
}
|
||||
|
||||
child_key_dot = g_strdup_printf("%s.", child->name);
|
||||
qdict_extract_subqdict(explicit_options, NULL, child_key_dot);
|
||||
qdict_extract_subqdict(options, &new_child_options, child_key_dot);
|
||||
g_free(child_key_dot);
|
||||
/* Check if the options contain a child reference */
|
||||
if (qdict_haskey(options, child->name)) {
|
||||
const char *childref = qdict_get_try_str(options, child->name);
|
||||
/*
|
||||
* The current child must not be reopened if the child
|
||||
* reference is null or points to a different node.
|
||||
*/
|
||||
if (g_strcmp0(childref, child->bs->node_name)) {
|
||||
continue;
|
||||
}
|
||||
/*
|
||||
* If the child reference points to the current child then
|
||||
* reopen it with its existing set of options (note that
|
||||
* it can still inherit new options from the parent).
|
||||
*/
|
||||
child_keep_old = true;
|
||||
} else {
|
||||
/* Extract child options ("child-name.*") */
|
||||
char *child_key_dot = g_strdup_printf("%s.", child->name);
|
||||
qdict_extract_subqdict(explicit_options, NULL, child_key_dot);
|
||||
qdict_extract_subqdict(options, &new_child_options, child_key_dot);
|
||||
g_free(child_key_dot);
|
||||
}
|
||||
|
||||
bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options,
|
||||
child->role, options, flags);
|
||||
child->role, options, flags, child_keep_old);
|
||||
}
|
||||
|
||||
return bs_queue;
|
||||
@ -3129,9 +3231,10 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
|
||||
|
||||
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
|
||||
BlockDriverState *bs,
|
||||
QDict *options)
|
||||
QDict *options, bool keep_old_opts)
|
||||
{
|
||||
return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, NULL, 0);
|
||||
return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, NULL, 0,
|
||||
keep_old_opts);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -3151,23 +3254,44 @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
|
||||
* All affected nodes must be drained between bdrv_reopen_queue() and
|
||||
* bdrv_reopen_multiple().
|
||||
*/
|
||||
int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp)
|
||||
int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
|
||||
{
|
||||
int ret = -1;
|
||||
BlockReopenQueueEntry *bs_entry, *next;
|
||||
Error *local_err = NULL;
|
||||
|
||||
assert(bs_queue != NULL);
|
||||
|
||||
QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
|
||||
assert(bs_entry->state.bs->quiesce_counter > 0);
|
||||
if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
|
||||
error_propagate(errp, local_err);
|
||||
if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, errp)) {
|
||||
goto cleanup;
|
||||
}
|
||||
bs_entry->prepared = true;
|
||||
}
|
||||
|
||||
QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
|
||||
BDRVReopenState *state = &bs_entry->state;
|
||||
ret = bdrv_check_perm(state->bs, bs_queue, state->perm,
|
||||
state->shared_perm, NULL, errp);
|
||||
if (ret < 0) {
|
||||
goto cleanup_perm;
|
||||
}
|
||||
/* Check if new_backing_bs would accept the new permissions */
|
||||
if (state->replace_backing_bs && state->new_backing_bs) {
|
||||
uint64_t nperm, nshared;
|
||||
bdrv_child_perm(state->bs, state->new_backing_bs,
|
||||
NULL, &child_backing, bs_queue,
|
||||
state->perm, state->shared_perm,
|
||||
&nperm, &nshared);
|
||||
ret = bdrv_check_update_perm(state->new_backing_bs, NULL,
|
||||
nperm, nshared, NULL, errp);
|
||||
if (ret < 0) {
|
||||
goto cleanup_perm;
|
||||
}
|
||||
}
|
||||
bs_entry->perms_checked = true;
|
||||
}
|
||||
|
||||
/* If we reach this point, we have success and just need to apply the
|
||||
* changes
|
||||
*/
|
||||
@ -3176,7 +3300,23 @@ int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **er
|
||||
}
|
||||
|
||||
ret = 0;
|
||||
cleanup_perm:
|
||||
QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
|
||||
BDRVReopenState *state = &bs_entry->state;
|
||||
|
||||
if (!bs_entry->perms_checked) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ret == 0) {
|
||||
bdrv_set_perm(state->bs, state->perm, state->shared_perm);
|
||||
} else {
|
||||
bdrv_abort_perm_update(state->bs);
|
||||
if (state->replace_backing_bs && state->new_backing_bs) {
|
||||
bdrv_abort_perm_update(state->new_backing_bs);
|
||||
}
|
||||
}
|
||||
}
|
||||
cleanup:
|
||||
QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
|
||||
if (ret) {
|
||||
@ -3186,6 +3326,9 @@ cleanup:
|
||||
qobject_unref(bs_entry->state.explicit_options);
|
||||
qobject_unref(bs_entry->state.options);
|
||||
}
|
||||
if (bs_entry->state.new_backing_bs) {
|
||||
bdrv_unref(bs_entry->state.new_backing_bs);
|
||||
}
|
||||
g_free(bs_entry);
|
||||
}
|
||||
g_free(bs_queue);
|
||||
@ -3203,8 +3346,8 @@ int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
|
||||
qdict_put_bool(opts, BDRV_OPT_READ_ONLY, read_only);
|
||||
|
||||
bdrv_subtree_drained_begin(bs);
|
||||
queue = bdrv_reopen_queue(NULL, bs, opts);
|
||||
ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, errp);
|
||||
queue = bdrv_reopen_queue(NULL, bs, opts, true);
|
||||
ret = bdrv_reopen_multiple(queue, errp);
|
||||
bdrv_subtree_drained_end(bs);
|
||||
|
||||
return ret;
|
||||
@ -3257,6 +3400,101 @@ static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
|
||||
*shared = cumulative_shared_perms;
|
||||
}
|
||||
|
||||
/*
|
||||
* Take a BDRVReopenState and check if the value of 'backing' in the
|
||||
* reopen_state->options QDict is valid or not.
|
||||
*
|
||||
* If 'backing' is missing from the QDict then return 0.
|
||||
*
|
||||
* If 'backing' contains the node name of the backing file of
|
||||
* reopen_state->bs then return 0.
|
||||
*
|
||||
* If 'backing' contains a different node name (or is null) then check
|
||||
* whether the current backing file can be replaced with the new one.
|
||||
* If that's the case then reopen_state->replace_backing_bs is set to
|
||||
* true and reopen_state->new_backing_bs contains a pointer to the new
|
||||
* backing BlockDriverState (or NULL).
|
||||
*
|
||||
* Return 0 on success, otherwise return < 0 and set @errp.
|
||||
*/
|
||||
static int bdrv_reopen_parse_backing(BDRVReopenState *reopen_state,
|
||||
Error **errp)
|
||||
{
|
||||
BlockDriverState *bs = reopen_state->bs;
|
||||
BlockDriverState *overlay_bs, *new_backing_bs;
|
||||
QObject *value;
|
||||
const char *str;
|
||||
|
||||
value = qdict_get(reopen_state->options, "backing");
|
||||
if (value == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (qobject_type(value)) {
|
||||
case QTYPE_QNULL:
|
||||
new_backing_bs = NULL;
|
||||
break;
|
||||
case QTYPE_QSTRING:
|
||||
str = qobject_get_try_str(value);
|
||||
new_backing_bs = bdrv_lookup_bs(NULL, str, errp);
|
||||
if (new_backing_bs == NULL) {
|
||||
return -EINVAL;
|
||||
} else if (bdrv_recurse_has_child(new_backing_bs, bs)) {
|
||||
error_setg(errp, "Making '%s' a backing file of '%s' "
|
||||
"would create a cycle", str, bs->node_name);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/* 'backing' does not allow any other data type */
|
||||
g_assert_not_reached();
|
||||
}
|
||||
|
||||
/*
|
||||
* TODO: before removing the x- prefix from x-blockdev-reopen we
|
||||
* should move the new backing file into the right AioContext
|
||||
* instead of returning an error.
|
||||
*/
|
||||
if (new_backing_bs) {
|
||||
if (bdrv_get_aio_context(new_backing_bs) != bdrv_get_aio_context(bs)) {
|
||||
error_setg(errp, "Cannot use a new backing file "
|
||||
"with a different AioContext");
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the "actual" backing file by skipping all links that point
|
||||
* to an implicit node, if any (e.g. a commit filter node).
|
||||
*/
|
||||
overlay_bs = bs;
|
||||
while (backing_bs(overlay_bs) && backing_bs(overlay_bs)->implicit) {
|
||||
overlay_bs = backing_bs(overlay_bs);
|
||||
}
|
||||
|
||||
/* If we want to replace the backing file we need some extra checks */
|
||||
if (new_backing_bs != backing_bs(overlay_bs)) {
|
||||
/* Check for implicit nodes between bs and its backing file */
|
||||
if (bs != overlay_bs) {
|
||||
error_setg(errp, "Cannot change backing link if '%s' has "
|
||||
"an implicit backing file", bs->node_name);
|
||||
return -EPERM;
|
||||
}
|
||||
/* Check if the backing link that we want to replace is frozen */
|
||||
if (bdrv_is_backing_chain_frozen(overlay_bs, backing_bs(overlay_bs),
|
||||
errp)) {
|
||||
return -EPERM;
|
||||
}
|
||||
reopen_state->replace_backing_bs = true;
|
||||
if (new_backing_bs) {
|
||||
bdrv_ref(new_backing_bs);
|
||||
reopen_state->new_backing_bs = new_backing_bs;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Prepares a BlockDriverState for reopen. All changes are staged in the
|
||||
* 'opaque' field of the BDRVReopenState, which is used and allocated by
|
||||
@ -3355,6 +3593,17 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
|
||||
}
|
||||
|
||||
if (drv->bdrv_reopen_prepare) {
|
||||
/*
|
||||
* If a driver-specific option is missing, it means that we
|
||||
* should reset it to its default value.
|
||||
* But not all options allow that, so we need to check it first.
|
||||
*/
|
||||
ret = bdrv_reset_options_allowed(reopen_state->bs,
|
||||
reopen_state->options, errp);
|
||||
if (ret) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
|
||||
if (ret) {
|
||||
if (local_err != NULL) {
|
||||
@ -3378,6 +3627,30 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
|
||||
|
||||
drv_prepared = true;
|
||||
|
||||
/*
|
||||
* We must provide the 'backing' option if the BDS has a backing
|
||||
* file or if the image file has a backing file name as part of
|
||||
* its metadata. Otherwise the 'backing' option can be omitted.
|
||||
*/
|
||||
if (drv->supports_backing && reopen_state->backing_missing &&
|
||||
(backing_bs(reopen_state->bs) || reopen_state->bs->backing_file[0])) {
|
||||
error_setg(errp, "backing is missing for '%s'",
|
||||
reopen_state->bs->node_name);
|
||||
ret = -EINVAL;
|
||||
goto error;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allow changing the 'backing' option. The new value can be
|
||||
* either a reference to an existing node (using its node name)
|
||||
* or NULL to simply detach the current backing file.
|
||||
*/
|
||||
ret = bdrv_reopen_parse_backing(reopen_state, errp);
|
||||
if (ret < 0) {
|
||||
goto error;
|
||||
}
|
||||
qdict_del(reopen_state->options, "backing");
|
||||
|
||||
/* Options that are not handled are only okay if they are unchanged
|
||||
* compared to the old state. It is expected that some options are only
|
||||
* used for the initial open, but not reopen (e.g. filename) */
|
||||
@ -3430,12 +3703,6 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
|
||||
} while ((entry = qdict_next(reopen_state->options, entry)));
|
||||
}
|
||||
|
||||
ret = bdrv_check_perm(reopen_state->bs, queue, reopen_state->perm,
|
||||
reopen_state->shared_perm, NULL, errp);
|
||||
if (ret < 0) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
ret = 0;
|
||||
|
||||
/* Restore the original reopen_state->options QDict */
|
||||
@ -3493,6 +3760,11 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state)
|
||||
bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
|
||||
bs->detect_zeroes = reopen_state->detect_zeroes;
|
||||
|
||||
if (reopen_state->replace_backing_bs) {
|
||||
qdict_del(bs->explicit_options, "backing");
|
||||
qdict_del(bs->options, "backing");
|
||||
}
|
||||
|
||||
/* Remove child references from bs->options and bs->explicit_options.
|
||||
* Child options were already removed in bdrv_reopen_queue_child() */
|
||||
QLIST_FOREACH(child, &bs->children, next) {
|
||||
@ -3500,10 +3772,22 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state)
|
||||
qdict_del(bs->options, child->name);
|
||||
}
|
||||
|
||||
bdrv_refresh_limits(bs, NULL);
|
||||
/*
|
||||
* Change the backing file if a new one was specified. We do this
|
||||
* after updating bs->options, so bdrv_refresh_filename() (called
|
||||
* from bdrv_set_backing_hd()) has the new values.
|
||||
*/
|
||||
if (reopen_state->replace_backing_bs) {
|
||||
BlockDriverState *old_backing_bs = backing_bs(bs);
|
||||
assert(!old_backing_bs || !old_backing_bs->implicit);
|
||||
/* Abort the permission update on the backing bs we're detaching */
|
||||
if (old_backing_bs) {
|
||||
bdrv_abort_perm_update(old_backing_bs);
|
||||
}
|
||||
bdrv_set_backing_hd(bs, reopen_state->new_backing_bs, &error_abort);
|
||||
}
|
||||
|
||||
bdrv_set_perm(reopen_state->bs, reopen_state->perm,
|
||||
reopen_state->shared_perm);
|
||||
bdrv_refresh_limits(bs, NULL);
|
||||
|
||||
new_can_write =
|
||||
!bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
|
||||
@ -3536,8 +3820,6 @@ void bdrv_reopen_abort(BDRVReopenState *reopen_state)
|
||||
if (drv->bdrv_reopen_abort) {
|
||||
drv->bdrv_reopen_abort(reopen_state);
|
||||
}
|
||||
|
||||
bdrv_abort_perm_update(reopen_state->bs);
|
||||
}
|
||||
|
||||
|
||||
@ -3717,6 +3999,11 @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
|
||||
if (!should_update_child(c, to)) {
|
||||
continue;
|
||||
}
|
||||
if (c->frozen) {
|
||||
error_setg(errp, "Cannot change '%s' link to '%s'",
|
||||
c->name, from->node_name);
|
||||
goto out;
|
||||
}
|
||||
list = g_slist_prepend(list, c);
|
||||
perm |= c->perm;
|
||||
shared &= c->shared_perm;
|
||||
@ -3928,6 +4215,63 @@ BlockDriverState *bdrv_find_base(BlockDriverState *bs)
|
||||
return bdrv_find_overlay(bs, NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return true if at least one of the backing links between @bs and
|
||||
* @base is frozen. @errp is set if that's the case.
|
||||
*/
|
||||
bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
|
||||
Error **errp)
|
||||
{
|
||||
BlockDriverState *i;
|
||||
|
||||
for (i = bs; i != base && i->backing; i = backing_bs(i)) {
|
||||
if (i->backing->frozen) {
|
||||
error_setg(errp, "Cannot change '%s' link from '%s' to '%s'",
|
||||
i->backing->name, i->node_name,
|
||||
backing_bs(i)->node_name);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Freeze all backing links between @bs and @base.
|
||||
* If any of the links is already frozen the operation is aborted and
|
||||
* none of the links are modified.
|
||||
* Returns 0 on success. On failure returns < 0 and sets @errp.
|
||||
*/
|
||||
int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
|
||||
Error **errp)
|
||||
{
|
||||
BlockDriverState *i;
|
||||
|
||||
if (bdrv_is_backing_chain_frozen(bs, base, errp)) {
|
||||
return -EPERM;
|
||||
}
|
||||
|
||||
for (i = bs; i != base && i->backing; i = backing_bs(i)) {
|
||||
i->backing->frozen = true;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Unfreeze all backing links between @bs and @base. The caller must
|
||||
* ensure that all links are frozen before using this function.
|
||||
*/
|
||||
void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base)
|
||||
{
|
||||
BlockDriverState *i;
|
||||
|
||||
for (i = bs; i != base && i->backing; i = backing_bs(i)) {
|
||||
assert(i->backing->frozen);
|
||||
i->backing->frozen = false;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Drops images above 'base' up to and including 'top', and sets the image
|
||||
* above 'top' to have base as its backing file.
|
||||
@ -3977,6 +4321,14 @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* This function changes all links that point to top and makes
|
||||
* them point to base. Check that none of them is frozen. */
|
||||
QLIST_FOREACH(c, &top->parents, next_parent) {
|
||||
if (c->frozen) {
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
|
||||
/* If 'base' recursively inherits from 'top' then we should set
|
||||
* base->inherits_from to top->inherits_from after 'top' and all
|
||||
* other intermediate nodes have been dropped.
|
||||
|
||||
@ -39,6 +39,7 @@ typedef struct CommitBlockJob {
|
||||
BlockDriverState *base_bs;
|
||||
BlockdevOnError on_error;
|
||||
bool base_read_only;
|
||||
bool chain_frozen;
|
||||
char *backing_file_str;
|
||||
} CommitBlockJob;
|
||||
|
||||
@ -68,6 +69,9 @@ static int commit_prepare(Job *job)
|
||||
{
|
||||
CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
|
||||
|
||||
bdrv_unfreeze_backing_chain(s->commit_top_bs, s->base_bs);
|
||||
s->chain_frozen = false;
|
||||
|
||||
/* Remove base node parent that still uses BLK_PERM_WRITE/RESIZE before
|
||||
* the normal backing chain can be restored. */
|
||||
blk_unref(s->base);
|
||||
@ -84,6 +88,10 @@ static void commit_abort(Job *job)
|
||||
CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
|
||||
BlockDriverState *top_bs = blk_bs(s->top);
|
||||
|
||||
if (s->chain_frozen) {
|
||||
bdrv_unfreeze_backing_chain(s->commit_top_bs, s->base_bs);
|
||||
}
|
||||
|
||||
/* Make sure commit_top_bs and top stay around until bdrv_replace_node() */
|
||||
bdrv_ref(top_bs);
|
||||
bdrv_ref(s->commit_top_bs);
|
||||
@ -330,6 +338,11 @@ void commit_start(const char *job_id, BlockDriverState *bs,
|
||||
}
|
||||
}
|
||||
|
||||
if (bdrv_freeze_backing_chain(commit_top_bs, base, errp) < 0) {
|
||||
goto fail;
|
||||
}
|
||||
s->chain_frozen = true;
|
||||
|
||||
ret = block_job_add_bdrv(&s->common, "base", base, 0, BLK_PERM_ALL, errp);
|
||||
if (ret < 0) {
|
||||
goto fail;
|
||||
@ -362,6 +375,9 @@ void commit_start(const char *job_id, BlockDriverState *bs,
|
||||
return;
|
||||
|
||||
fail:
|
||||
if (s->chain_frozen) {
|
||||
bdrv_unfreeze_backing_chain(commit_top_bs, base);
|
||||
}
|
||||
if (s->base) {
|
||||
blk_unref(s->base);
|
||||
}
|
||||
|
||||
@ -144,6 +144,9 @@ typedef struct BDRVRawState {
|
||||
uint64_t locked_perm;
|
||||
uint64_t locked_shared_perm;
|
||||
|
||||
int perm_change_fd;
|
||||
BDRVReopenState *reopen_state;
|
||||
|
||||
#ifdef CONFIG_XFS
|
||||
bool is_xfs:1;
|
||||
#endif
|
||||
@ -373,13 +376,21 @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
|
||||
}
|
||||
}
|
||||
|
||||
static void raw_parse_flags(int bdrv_flags, int *open_flags)
|
||||
static void raw_parse_flags(int bdrv_flags, int *open_flags, bool has_writers)
|
||||
{
|
||||
bool read_write = false;
|
||||
assert(open_flags != NULL);
|
||||
|
||||
*open_flags |= O_BINARY;
|
||||
*open_flags &= ~O_ACCMODE;
|
||||
if (bdrv_flags & BDRV_O_RDWR) {
|
||||
|
||||
if (bdrv_flags & BDRV_O_AUTO_RDONLY) {
|
||||
read_write = has_writers;
|
||||
} else if (bdrv_flags & BDRV_O_RDWR) {
|
||||
read_write = true;
|
||||
}
|
||||
|
||||
if (read_write) {
|
||||
*open_flags |= O_RDWR;
|
||||
} else {
|
||||
*open_flags |= O_RDONLY;
|
||||
@ -431,6 +442,8 @@ static QemuOptsList raw_runtime_opts = {
|
||||
},
|
||||
};
|
||||
|
||||
static const char *const mutable_opts[] = { "x-check-cache-dropped", NULL };
|
||||
|
||||
static int raw_open_common(BlockDriverState *bs, QDict *options,
|
||||
int bdrv_flags, int open_flags,
|
||||
bool device, Error **errp)
|
||||
@ -515,24 +528,12 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
|
||||
false);
|
||||
|
||||
s->open_flags = open_flags;
|
||||
raw_parse_flags(bdrv_flags, &s->open_flags);
|
||||
raw_parse_flags(bdrv_flags, &s->open_flags, false);
|
||||
|
||||
s->fd = -1;
|
||||
fd = qemu_open(filename, s->open_flags, 0644);
|
||||
ret = fd < 0 ? -errno : 0;
|
||||
|
||||
if (ret == -EACCES || ret == -EROFS) {
|
||||
/* Try to degrade to read-only, but if it doesn't work, still use the
|
||||
* normal error message. */
|
||||
if (bdrv_apply_auto_read_only(bs, NULL, NULL) == 0) {
|
||||
bdrv_flags &= ~BDRV_O_RDWR;
|
||||
raw_parse_flags(bdrv_flags, &s->open_flags);
|
||||
assert(!(s->open_flags & O_CREAT));
|
||||
fd = qemu_open(filename, s->open_flags);
|
||||
ret = fd < 0 ? -errno : 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (ret < 0) {
|
||||
error_setg_errno(errp, -ret, "Could not open '%s'", filename);
|
||||
if (ret == -EROFS) {
|
||||
@ -842,13 +843,77 @@ static int raw_handle_perm_lock(BlockDriverState *bs,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
|
||||
int *open_flags, uint64_t perm, bool force_dup,
|
||||
Error **errp)
|
||||
{
|
||||
BDRVRawState *s = bs->opaque;
|
||||
int fd = -1;
|
||||
int ret;
|
||||
bool has_writers = perm &
|
||||
(BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_RESIZE);
|
||||
int fcntl_flags = O_APPEND | O_NONBLOCK;
|
||||
#ifdef O_NOATIME
|
||||
fcntl_flags |= O_NOATIME;
|
||||
#endif
|
||||
|
||||
*open_flags = 0;
|
||||
if (s->type == FTYPE_CD) {
|
||||
*open_flags |= O_NONBLOCK;
|
||||
}
|
||||
|
||||
raw_parse_flags(flags, open_flags, has_writers);
|
||||
|
||||
#ifdef O_ASYNC
|
||||
/* Not all operating systems have O_ASYNC, and those that don't
|
||||
* will not let us track the state into rs->open_flags (typically
|
||||
* you achieve the same effect with an ioctl, for example I_SETSIG
|
||||
* on Solaris). But we do not use O_ASYNC, so that's fine.
|
||||
*/
|
||||
assert((s->open_flags & O_ASYNC) == 0);
|
||||
#endif
|
||||
|
||||
if (!force_dup && *open_flags == s->open_flags) {
|
||||
/* We're lucky, the existing fd is fine */
|
||||
return s->fd;
|
||||
}
|
||||
|
||||
if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
|
||||
/* dup the original fd */
|
||||
fd = qemu_dup(s->fd);
|
||||
if (fd >= 0) {
|
||||
ret = fcntl_setfl(fd, *open_flags);
|
||||
if (ret) {
|
||||
qemu_close(fd);
|
||||
fd = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
|
||||
if (fd == -1) {
|
||||
const char *normalized_filename = bs->filename;
|
||||
ret = raw_normalize_devicepath(&normalized_filename, errp);
|
||||
if (ret >= 0) {
|
||||
assert(!(*open_flags & O_CREAT));
|
||||
fd = qemu_open(normalized_filename, *open_flags);
|
||||
if (fd == -1) {
|
||||
error_setg_errno(errp, errno, "Could not reopen file");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
static int raw_reopen_prepare(BDRVReopenState *state,
|
||||
BlockReopenQueue *queue, Error **errp)
|
||||
{
|
||||
BDRVRawState *s;
|
||||
BDRVRawReopenState *rs;
|
||||
QemuOpts *opts;
|
||||
int ret = 0;
|
||||
int ret;
|
||||
Error *local_err = NULL;
|
||||
|
||||
assert(state != NULL);
|
||||
@ -858,7 +923,6 @@ static int raw_reopen_prepare(BDRVReopenState *state,
|
||||
|
||||
state->opaque = g_new0(BDRVRawReopenState, 1);
|
||||
rs = state->opaque;
|
||||
rs->fd = -1;
|
||||
|
||||
/* Handle options changes */
|
||||
opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
|
||||
@ -877,50 +941,12 @@ static int raw_reopen_prepare(BDRVReopenState *state,
|
||||
* bdrv_reopen_prepare() will detect changes and complain. */
|
||||
qemu_opts_to_qdict(opts, state->options);
|
||||
|
||||
if (s->type == FTYPE_CD) {
|
||||
rs->open_flags |= O_NONBLOCK;
|
||||
}
|
||||
|
||||
raw_parse_flags(state->flags, &rs->open_flags);
|
||||
|
||||
int fcntl_flags = O_APPEND | O_NONBLOCK;
|
||||
#ifdef O_NOATIME
|
||||
fcntl_flags |= O_NOATIME;
|
||||
#endif
|
||||
|
||||
#ifdef O_ASYNC
|
||||
/* Not all operating systems have O_ASYNC, and those that don't
|
||||
* will not let us track the state into rs->open_flags (typically
|
||||
* you achieve the same effect with an ioctl, for example I_SETSIG
|
||||
* on Solaris). But we do not use O_ASYNC, so that's fine.
|
||||
*/
|
||||
assert((s->open_flags & O_ASYNC) == 0);
|
||||
#endif
|
||||
|
||||
if ((rs->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
|
||||
/* dup the original fd */
|
||||
rs->fd = qemu_dup(s->fd);
|
||||
if (rs->fd >= 0) {
|
||||
ret = fcntl_setfl(rs->fd, rs->open_flags);
|
||||
if (ret) {
|
||||
qemu_close(rs->fd);
|
||||
rs->fd = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
|
||||
if (rs->fd == -1) {
|
||||
const char *normalized_filename = state->bs->filename;
|
||||
ret = raw_normalize_devicepath(&normalized_filename, errp);
|
||||
if (ret >= 0) {
|
||||
assert(!(rs->open_flags & O_CREAT));
|
||||
rs->fd = qemu_open(normalized_filename, rs->open_flags);
|
||||
if (rs->fd == -1) {
|
||||
error_setg_errno(errp, errno, "Could not reopen file");
|
||||
ret = -1;
|
||||
}
|
||||
}
|
||||
rs->fd = raw_reconfigure_getfd(state->bs, state->flags, &rs->open_flags,
|
||||
state->perm, true, &local_err);
|
||||
if (local_err) {
|
||||
error_propagate(errp, local_err);
|
||||
ret = -1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Fail already reopen_prepare() if we can't get a working O_DIRECT
|
||||
@ -928,13 +954,19 @@ static int raw_reopen_prepare(BDRVReopenState *state,
|
||||
if (rs->fd != -1) {
|
||||
raw_probe_alignment(state->bs, rs->fd, &local_err);
|
||||
if (local_err) {
|
||||
qemu_close(rs->fd);
|
||||
rs->fd = -1;
|
||||
error_propagate(errp, local_err);
|
||||
ret = -EINVAL;
|
||||
goto out_fd;
|
||||
}
|
||||
}
|
||||
|
||||
s->reopen_state = state;
|
||||
ret = 0;
|
||||
out_fd:
|
||||
if (ret < 0) {
|
||||
qemu_close(rs->fd);
|
||||
rs->fd = -1;
|
||||
}
|
||||
out:
|
||||
qemu_opts_del(opts);
|
||||
return ret;
|
||||
@ -944,29 +976,25 @@ static void raw_reopen_commit(BDRVReopenState *state)
|
||||
{
|
||||
BDRVRawReopenState *rs = state->opaque;
|
||||
BDRVRawState *s = state->bs->opaque;
|
||||
Error *local_err = NULL;
|
||||
|
||||
s->check_cache_dropped = rs->check_cache_dropped;
|
||||
s->open_flags = rs->open_flags;
|
||||
|
||||
/* Copy locks to the new fd before closing the old one. */
|
||||
raw_apply_lock_bytes(NULL, rs->fd, s->locked_perm,
|
||||
s->locked_shared_perm, false, &local_err);
|
||||
if (local_err) {
|
||||
/* shouldn't fail in a sane host, but report it just in case. */
|
||||
error_report_err(local_err);
|
||||
}
|
||||
qemu_close(s->fd);
|
||||
s->fd = rs->fd;
|
||||
|
||||
g_free(state->opaque);
|
||||
state->opaque = NULL;
|
||||
|
||||
assert(s->reopen_state == state);
|
||||
s->reopen_state = NULL;
|
||||
}
|
||||
|
||||
|
||||
static void raw_reopen_abort(BDRVReopenState *state)
|
||||
{
|
||||
BDRVRawReopenState *rs = state->opaque;
|
||||
BDRVRawState *s = state->bs->opaque;
|
||||
|
||||
/* nothing to do if NULL, we didn't get far enough */
|
||||
if (rs == NULL) {
|
||||
@ -979,6 +1007,9 @@ static void raw_reopen_abort(BDRVReopenState *state)
|
||||
}
|
||||
g_free(state->opaque);
|
||||
state->opaque = NULL;
|
||||
|
||||
assert(s->reopen_state == state);
|
||||
s->reopen_state = NULL;
|
||||
}
|
||||
|
||||
static int hdev_get_max_transfer_length(BlockDriverState *bs, int fd)
|
||||
@ -2664,12 +2695,78 @@ static QemuOptsList raw_create_opts = {
|
||||
static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
|
||||
Error **errp)
|
||||
{
|
||||
return raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
|
||||
BDRVRawState *s = bs->opaque;
|
||||
BDRVRawReopenState *rs = NULL;
|
||||
int open_flags;
|
||||
int ret;
|
||||
|
||||
if (s->perm_change_fd) {
|
||||
/*
|
||||
* In the context of reopen, this function may be called several times
|
||||
* (directly and recursively while change permissions of the parent).
|
||||
* This is even true for children that don't inherit from the original
|
||||
* reopen node, so s->reopen_state is not set.
|
||||
*
|
||||
* Ignore all but the first call.
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (s->reopen_state) {
|
||||
/* We already have a new file descriptor to set permissions for */
|
||||
assert(s->reopen_state->perm == perm);
|
||||
assert(s->reopen_state->shared_perm == shared);
|
||||
rs = s->reopen_state->opaque;
|
||||
s->perm_change_fd = rs->fd;
|
||||
} else {
|
||||
/* We may need a new fd if auto-read-only switches the mode */
|
||||
ret = raw_reconfigure_getfd(bs, bs->open_flags, &open_flags, perm,
|
||||
false, errp);
|
||||
if (ret < 0) {
|
||||
return ret;
|
||||
} else if (ret != s->fd) {
|
||||
s->perm_change_fd = ret;
|
||||
}
|
||||
}
|
||||
|
||||
/* Prepare permissions on old fd to avoid conflicts between old and new,
|
||||
* but keep everything locked that new will need. */
|
||||
ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
|
||||
if (ret < 0) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* Copy locks to the new fd */
|
||||
if (s->perm_change_fd) {
|
||||
ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
|
||||
false, errp);
|
||||
if (ret < 0) {
|
||||
raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
if (s->perm_change_fd && !s->reopen_state) {
|
||||
qemu_close(s->perm_change_fd);
|
||||
}
|
||||
s->perm_change_fd = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
|
||||
{
|
||||
BDRVRawState *s = bs->opaque;
|
||||
|
||||
/* For reopen, we have already switched to the new fd (.bdrv_set_perm is
|
||||
* called after .bdrv_reopen_commit) */
|
||||
if (s->perm_change_fd && s->fd != s->perm_change_fd) {
|
||||
qemu_close(s->fd);
|
||||
s->fd = s->perm_change_fd;
|
||||
}
|
||||
s->perm_change_fd = 0;
|
||||
|
||||
raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
|
||||
s->perm = perm;
|
||||
s->shared_perm = shared;
|
||||
@ -2677,6 +2774,15 @@ static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
|
||||
|
||||
static void raw_abort_perm_update(BlockDriverState *bs)
|
||||
{
|
||||
BDRVRawState *s = bs->opaque;
|
||||
|
||||
/* For reopen, .bdrv_reopen_abort is called afterwards and will close
|
||||
* the file descriptor. */
|
||||
if (s->perm_change_fd && !s->reopen_state) {
|
||||
qemu_close(s->perm_change_fd);
|
||||
}
|
||||
s->perm_change_fd = 0;
|
||||
|
||||
raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
|
||||
}
|
||||
|
||||
@ -2766,6 +2872,7 @@ BlockDriver bdrv_file = {
|
||||
.bdrv_set_perm = raw_set_perm,
|
||||
.bdrv_abort_perm_update = raw_abort_perm_update,
|
||||
.create_opts = &raw_create_opts,
|
||||
.mutable_opts = mutable_opts,
|
||||
};
|
||||
|
||||
/***********************************************/
|
||||
@ -3217,6 +3324,7 @@ static BlockDriver bdrv_host_device = {
|
||||
.bdrv_reopen_abort = raw_reopen_abort,
|
||||
.bdrv_co_create_opts = hdev_co_create_opts,
|
||||
.create_opts = &raw_create_opts,
|
||||
.mutable_opts = mutable_opts,
|
||||
.bdrv_co_invalidate_cache = raw_co_invalidate_cache,
|
||||
.bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
|
||||
|
||||
@ -3343,6 +3451,7 @@ static BlockDriver bdrv_host_cdrom = {
|
||||
.bdrv_reopen_abort = raw_reopen_abort,
|
||||
.bdrv_co_create_opts = hdev_co_create_opts,
|
||||
.create_opts = &raw_create_opts,
|
||||
.mutable_opts = mutable_opts,
|
||||
.bdrv_co_invalidate_cache = raw_co_invalidate_cache,
|
||||
|
||||
|
||||
@ -3476,6 +3585,7 @@ static BlockDriver bdrv_host_cdrom = {
|
||||
.bdrv_reopen_abort = raw_reopen_abort,
|
||||
.bdrv_co_create_opts = hdev_co_create_opts,
|
||||
.create_opts = &raw_create_opts,
|
||||
.mutable_opts = mutable_opts,
|
||||
|
||||
.bdrv_co_preadv = raw_co_preadv,
|
||||
.bdrv_co_pwritev = raw_co_pwritev,
|
||||
|
||||
@ -20,6 +20,10 @@
|
||||
#include "qemu/option.h"
|
||||
#include "qemu/cutils.h"
|
||||
|
||||
#ifdef CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT
|
||||
# define glfs_ftruncate(fd, offset) glfs_ftruncate(fd, offset, NULL, NULL)
|
||||
#endif
|
||||
|
||||
#define GLUSTER_OPT_FILENAME "filename"
|
||||
#define GLUSTER_OPT_VOLUME "volume"
|
||||
#define GLUSTER_OPT_PATH "path"
|
||||
@ -725,7 +729,11 @@ static struct glfs *qemu_gluster_init(BlockdevOptionsGluster *gconf,
|
||||
/*
|
||||
* AIO callback routine called from GlusterFS thread.
|
||||
*/
|
||||
static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret, void *arg)
|
||||
static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret,
|
||||
#ifdef CONFIG_GLUSTERFS_IOCB_HAS_STAT
|
||||
struct glfs_stat *pre, struct glfs_stat *post,
|
||||
#endif
|
||||
void *arg)
|
||||
{
|
||||
GlusterAIOCB *acb = (GlusterAIOCB *)arg;
|
||||
|
||||
|
||||
@ -630,6 +630,10 @@ static int mirror_exit_common(Job *job)
|
||||
}
|
||||
s->prepared = true;
|
||||
|
||||
if (bdrv_chain_contains(src, target_bs)) {
|
||||
bdrv_unfreeze_backing_chain(mirror_top_bs, target_bs);
|
||||
}
|
||||
|
||||
bdrv_release_dirty_bitmap(src, s->dirty_bitmap);
|
||||
|
||||
/* Make sure that the source BDS doesn't go away during bdrv_replace_node,
|
||||
@ -1639,6 +1643,10 @@ static void mirror_start_job(const char *job_id, BlockDriverState *bs,
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
if (bdrv_freeze_backing_chain(mirror_top_bs, target, errp) < 0) {
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
QTAILQ_INIT(&s->ops_in_flight);
|
||||
|
||||
12
block/qapi.c
12
block/qapi.c
@ -493,14 +493,14 @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
|
||||
}
|
||||
|
||||
bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_READ],
|
||||
&ds->has_x_rd_latency_histogram,
|
||||
&ds->x_rd_latency_histogram);
|
||||
&ds->has_rd_latency_histogram,
|
||||
&ds->rd_latency_histogram);
|
||||
bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_WRITE],
|
||||
&ds->has_x_wr_latency_histogram,
|
||||
&ds->x_wr_latency_histogram);
|
||||
&ds->has_wr_latency_histogram,
|
||||
&ds->wr_latency_histogram);
|
||||
bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_FLUSH],
|
||||
&ds->has_x_flush_latency_histogram,
|
||||
&ds->x_flush_latency_histogram);
|
||||
&ds->has_flush_latency_histogram,
|
||||
&ds->flush_latency_histogram);
|
||||
}
|
||||
|
||||
static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs,
|
||||
|
||||
@ -627,6 +627,30 @@ int qcow2_validate_table(BlockDriverState *bs, uint64_t offset,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const char *const mutable_opts[] = {
|
||||
QCOW2_OPT_LAZY_REFCOUNTS,
|
||||
QCOW2_OPT_DISCARD_REQUEST,
|
||||
QCOW2_OPT_DISCARD_SNAPSHOT,
|
||||
QCOW2_OPT_DISCARD_OTHER,
|
||||
QCOW2_OPT_OVERLAP,
|
||||
QCOW2_OPT_OVERLAP_TEMPLATE,
|
||||
QCOW2_OPT_OVERLAP_MAIN_HEADER,
|
||||
QCOW2_OPT_OVERLAP_ACTIVE_L1,
|
||||
QCOW2_OPT_OVERLAP_ACTIVE_L2,
|
||||
QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
|
||||
QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
|
||||
QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
|
||||
QCOW2_OPT_OVERLAP_INACTIVE_L1,
|
||||
QCOW2_OPT_OVERLAP_INACTIVE_L2,
|
||||
QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
|
||||
QCOW2_OPT_CACHE_SIZE,
|
||||
QCOW2_OPT_L2_CACHE_SIZE,
|
||||
QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
|
||||
QCOW2_OPT_REFCOUNT_CACHE_SIZE,
|
||||
QCOW2_OPT_CACHE_CLEAN_INTERVAL,
|
||||
NULL
|
||||
};
|
||||
|
||||
static QemuOptsList qcow2_runtime_opts = {
|
||||
.name = "qcow2",
|
||||
.head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
|
||||
@ -5275,6 +5299,7 @@ BlockDriver bdrv_qcow2 = {
|
||||
|
||||
.create_opts = &qcow2_create_opts,
|
||||
.strong_runtime_opts = qcow2_strong_runtime_opts,
|
||||
.mutable_opts = mutable_opts,
|
||||
.bdrv_co_check = qcow2_co_check,
|
||||
.bdrv_amend_options = qcow2_amend_options,
|
||||
|
||||
|
||||
@ -37,6 +37,8 @@ typedef struct BDRVRawState {
|
||||
bool has_size;
|
||||
} BDRVRawState;
|
||||
|
||||
static const char *const mutable_opts[] = { "offset", "size", NULL };
|
||||
|
||||
static QemuOptsList raw_runtime_opts = {
|
||||
.name = "raw",
|
||||
.head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
|
||||
@ -570,6 +572,7 @@ BlockDriver bdrv_raw = {
|
||||
.create_opts = &raw_create_opts,
|
||||
.bdrv_has_zero_init = &raw_has_zero_init,
|
||||
.strong_runtime_opts = raw_strong_runtime_opts,
|
||||
.mutable_opts = mutable_opts,
|
||||
};
|
||||
|
||||
static void bdrv_raw_init(void)
|
||||
|
||||
@ -374,19 +374,18 @@ static void reopen_backing_file(BlockDriverState *bs, bool writable,
|
||||
QDict *opts = qdict_new();
|
||||
qdict_put_bool(opts, BDRV_OPT_READ_ONLY, !writable);
|
||||
reopen_queue = bdrv_reopen_queue(reopen_queue, s->hidden_disk->bs,
|
||||
opts);
|
||||
opts, true);
|
||||
}
|
||||
|
||||
if (s->orig_secondary_read_only) {
|
||||
QDict *opts = qdict_new();
|
||||
qdict_put_bool(opts, BDRV_OPT_READ_ONLY, !writable);
|
||||
reopen_queue = bdrv_reopen_queue(reopen_queue, s->secondary_disk->bs,
|
||||
opts);
|
||||
opts, true);
|
||||
}
|
||||
|
||||
if (reopen_queue) {
|
||||
bdrv_reopen_multiple(bdrv_get_aio_context(bs),
|
||||
reopen_queue, &local_err);
|
||||
bdrv_reopen_multiple(reopen_queue, &local_err);
|
||||
error_propagate(errp, local_err);
|
||||
}
|
||||
|
||||
|
||||
@ -35,6 +35,7 @@ typedef struct StreamBlockJob {
|
||||
BlockdevOnError on_error;
|
||||
char *backing_file_str;
|
||||
bool bs_read_only;
|
||||
bool chain_frozen;
|
||||
} StreamBlockJob;
|
||||
|
||||
static int coroutine_fn stream_populate(BlockBackend *blk,
|
||||
@ -49,6 +50,16 @@ static int coroutine_fn stream_populate(BlockBackend *blk,
|
||||
return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ);
|
||||
}
|
||||
|
||||
static void stream_abort(Job *job)
|
||||
{
|
||||
StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
|
||||
|
||||
if (s->chain_frozen) {
|
||||
BlockJob *bjob = &s->common;
|
||||
bdrv_unfreeze_backing_chain(blk_bs(bjob->blk), s->base);
|
||||
}
|
||||
}
|
||||
|
||||
static int stream_prepare(Job *job)
|
||||
{
|
||||
StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
|
||||
@ -58,6 +69,9 @@ static int stream_prepare(Job *job)
|
||||
Error *local_err = NULL;
|
||||
int ret = 0;
|
||||
|
||||
bdrv_unfreeze_backing_chain(bs, base);
|
||||
s->chain_frozen = false;
|
||||
|
||||
if (bs->backing) {
|
||||
const char *base_id = NULL, *base_fmt = NULL;
|
||||
if (base) {
|
||||
@ -208,6 +222,7 @@ static const BlockJobDriver stream_job_driver = {
|
||||
.free = block_job_free,
|
||||
.run = stream_run,
|
||||
.prepare = stream_prepare,
|
||||
.abort = stream_abort,
|
||||
.clean = stream_clean,
|
||||
.user_resume = block_job_user_resume,
|
||||
.drain = block_job_drain,
|
||||
@ -254,9 +269,15 @@ void stream_start(const char *job_id, BlockDriverState *bs,
|
||||
&error_abort);
|
||||
}
|
||||
|
||||
if (bdrv_freeze_backing_chain(bs, base, errp) < 0) {
|
||||
job_early_fail(&s->common.job);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
s->base = base;
|
||||
s->backing_file_str = g_strdup(backing_file_str);
|
||||
s->bs_read_only = bs_read_only;
|
||||
s->chain_frozen = true;
|
||||
|
||||
s->on_error = on_error;
|
||||
trace_stream_start(bs, base, s);
|
||||
|
||||
61
blockdev.c
61
blockdev.c
@ -4287,6 +4287,53 @@ fail:
|
||||
visit_free(v);
|
||||
}
|
||||
|
||||
void qmp_x_blockdev_reopen(BlockdevOptions *options, Error **errp)
|
||||
{
|
||||
BlockDriverState *bs;
|
||||
AioContext *ctx;
|
||||
QObject *obj;
|
||||
Visitor *v = qobject_output_visitor_new(&obj);
|
||||
Error *local_err = NULL;
|
||||
BlockReopenQueue *queue;
|
||||
QDict *qdict;
|
||||
|
||||
/* Check for the selected node name */
|
||||
if (!options->has_node_name) {
|
||||
error_setg(errp, "Node name not specified");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
bs = bdrv_find_node(options->node_name);
|
||||
if (!bs) {
|
||||
error_setg(errp, "Cannot find node named '%s'", options->node_name);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* Put all options in a QDict and flatten it */
|
||||
visit_type_BlockdevOptions(v, NULL, &options, &local_err);
|
||||
if (local_err) {
|
||||
error_propagate(errp, local_err);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
visit_complete(v, &obj);
|
||||
qdict = qobject_to(QDict, obj);
|
||||
|
||||
qdict_flatten(qdict);
|
||||
|
||||
/* Perform the reopen operation */
|
||||
ctx = bdrv_get_aio_context(bs);
|
||||
aio_context_acquire(ctx);
|
||||
bdrv_subtree_drained_begin(bs);
|
||||
queue = bdrv_reopen_queue(NULL, bs, qdict, false);
|
||||
bdrv_reopen_multiple(queue, errp);
|
||||
bdrv_subtree_drained_end(bs);
|
||||
aio_context_release(ctx);
|
||||
|
||||
fail:
|
||||
visit_free(v);
|
||||
}
|
||||
|
||||
void qmp_blockdev_del(const char *node_name, Error **errp)
|
||||
{
|
||||
AioContext *aio_context;
|
||||
@ -4452,22 +4499,22 @@ void qmp_x_blockdev_set_iothread(const char *node_name, StrOrNull *iothread,
|
||||
aio_context_release(old_context);
|
||||
}
|
||||
|
||||
void qmp_x_block_latency_histogram_set(
|
||||
const char *device,
|
||||
void qmp_block_latency_histogram_set(
|
||||
const char *id,
|
||||
bool has_boundaries, uint64List *boundaries,
|
||||
bool has_boundaries_read, uint64List *boundaries_read,
|
||||
bool has_boundaries_write, uint64List *boundaries_write,
|
||||
bool has_boundaries_flush, uint64List *boundaries_flush,
|
||||
Error **errp)
|
||||
{
|
||||
BlockBackend *blk = blk_by_name(device);
|
||||
BlockBackend *blk = qmp_get_blk(NULL, id, errp);
|
||||
BlockAcctStats *stats;
|
||||
int ret;
|
||||
|
||||
if (!blk) {
|
||||
error_setg(errp, "Device '%s' not found", device);
|
||||
return;
|
||||
}
|
||||
|
||||
stats = blk_get_stats(blk);
|
||||
|
||||
if (!has_boundaries && !has_boundaries_read && !has_boundaries_write &&
|
||||
@ -4482,7 +4529,7 @@ void qmp_x_block_latency_histogram_set(
|
||||
stats, BLOCK_ACCT_READ,
|
||||
has_boundaries_read ? boundaries_read : boundaries);
|
||||
if (ret) {
|
||||
error_setg(errp, "Device '%s' set read boundaries fail", device);
|
||||
error_setg(errp, "Device '%s' set read boundaries fail", id);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -4492,7 +4539,7 @@ void qmp_x_block_latency_histogram_set(
|
||||
stats, BLOCK_ACCT_WRITE,
|
||||
has_boundaries_write ? boundaries_write : boundaries);
|
||||
if (ret) {
|
||||
error_setg(errp, "Device '%s' set write boundaries fail", device);
|
||||
error_setg(errp, "Device '%s' set write boundaries fail", id);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -4502,7 +4549,7 @@ void qmp_x_block_latency_histogram_set(
|
||||
stats, BLOCK_ACCT_FLUSH,
|
||||
has_boundaries_flush ? boundaries_flush : boundaries);
|
||||
if (ret) {
|
||||
error_setg(errp, "Device '%s' set flush boundaries fail", device);
|
||||
error_setg(errp, "Device '%s' set flush boundaries fail", id);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
42
configure
vendored
42
configure
vendored
@ -456,6 +456,8 @@ glusterfs_xlator_opt="no"
|
||||
glusterfs_discard="no"
|
||||
glusterfs_fallocate="no"
|
||||
glusterfs_zerofill="no"
|
||||
glusterfs_ftruncate_has_stat="no"
|
||||
glusterfs_iocb_has_stat="no"
|
||||
gtk=""
|
||||
gtk_gl="no"
|
||||
tls_priority="NORMAL"
|
||||
@ -4091,6 +4093,38 @@ if test "$glusterfs" != "no" ; then
|
||||
glusterfs_fallocate="yes"
|
||||
glusterfs_zerofill="yes"
|
||||
fi
|
||||
cat > $TMPC << EOF
|
||||
#include <glusterfs/api/glfs.h>
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
/* new glfs_ftruncate() passes two additional args */
|
||||
return glfs_ftruncate(NULL, 0, NULL, NULL);
|
||||
}
|
||||
EOF
|
||||
if compile_prog "$glusterfs_cflags" "$glusterfs_libs" ; then
|
||||
glusterfs_ftruncate_has_stat="yes"
|
||||
fi
|
||||
cat > $TMPC << EOF
|
||||
#include <glusterfs/api/glfs.h>
|
||||
|
||||
/* new glfs_io_cbk() passes two additional glfs_stat structs */
|
||||
static void
|
||||
glusterfs_iocb(glfs_fd_t *fd, ssize_t ret, struct glfs_stat *prestat, struct glfs_stat *poststat, void *data)
|
||||
{}
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
glfs_io_cbk iocb = &glusterfs_iocb;
|
||||
iocb(NULL, 0 , NULL, NULL, NULL);
|
||||
return 0;
|
||||
}
|
||||
EOF
|
||||
if compile_prog "$glusterfs_cflags" "$glusterfs_libs" ; then
|
||||
glusterfs_iocb_has_stat="yes"
|
||||
fi
|
||||
else
|
||||
if test "$glusterfs" = "yes" ; then
|
||||
feature_not_found "GlusterFS backend support" \
|
||||
@ -6976,6 +7010,14 @@ if test "$glusterfs_zerofill" = "yes" ; then
|
||||
echo "CONFIG_GLUSTERFS_ZEROFILL=y" >> $config_host_mak
|
||||
fi
|
||||
|
||||
if test "$glusterfs_ftruncate_has_stat" = "yes" ; then
|
||||
echo "CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT=y" >> $config_host_mak
|
||||
fi
|
||||
|
||||
if test "$glusterfs_iocb_has_stat" = "yes" ; then
|
||||
echo "CONFIG_GLUSTERFS_IOCB_HAS_STAT=y" >> $config_host_mak
|
||||
fi
|
||||
|
||||
if test "$libssh2" = "yes" ; then
|
||||
echo "CONFIG_LIBSSH2=m" >> $config_host_mak
|
||||
echo "LIBSSH2_CFLAGS=$libssh2_cflags" >> $config_host_mak
|
||||
|
||||
@ -324,8 +324,8 @@ static uint16_t nvme_write_zeros(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd,
|
||||
const uint8_t data_shift = ns->id_ns.lbaf[lba_index].ds;
|
||||
uint64_t slba = le64_to_cpu(rw->slba);
|
||||
uint32_t nlb = le16_to_cpu(rw->nlb) + 1;
|
||||
uint64_t aio_slba = slba << (data_shift - BDRV_SECTOR_BITS);
|
||||
uint32_t aio_nlb = nlb << (data_shift - BDRV_SECTOR_BITS);
|
||||
uint64_t offset = slba << data_shift;
|
||||
uint32_t count = nlb << data_shift;
|
||||
|
||||
if (unlikely(slba + nlb > ns->id_ns.nsze)) {
|
||||
trace_nvme_err_invalid_lba_range(slba, nlb, ns->id_ns.nsze);
|
||||
@ -335,7 +335,7 @@ static uint16_t nvme_write_zeros(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd,
|
||||
req->has_sg = false;
|
||||
block_acct_start(blk_get_stats(n->conf.blk), &req->acct, 0,
|
||||
BLOCK_ACCT_WRITE);
|
||||
req->aiocb = blk_aio_pwrite_zeroes(n->conf.blk, aio_slba, aio_nlb,
|
||||
req->aiocb = blk_aio_pwrite_zeroes(n->conf.blk, offset, count,
|
||||
BDRV_REQ_MAY_UNMAP, nvme_rw_cb, req);
|
||||
return NVME_NO_COMPLETE;
|
||||
}
|
||||
|
||||
@ -187,6 +187,9 @@ typedef struct BDRVReopenState {
|
||||
BlockDriverState *bs;
|
||||
int flags;
|
||||
BlockdevDetectZeroesOptions detect_zeroes;
|
||||
bool backing_missing;
|
||||
bool replace_backing_bs; /* new_backing_bs is ignored if this is false */
|
||||
BlockDriverState *new_backing_bs; /* If NULL then detach the current bs */
|
||||
uint64_t perm, shared_perm;
|
||||
QDict *options;
|
||||
QDict *explicit_options;
|
||||
@ -299,8 +302,9 @@ BlockDriverState *bdrv_open(const char *filename, const char *reference,
|
||||
BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
|
||||
int flags, Error **errp);
|
||||
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
|
||||
BlockDriverState *bs, QDict *options);
|
||||
int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp);
|
||||
BlockDriverState *bs, QDict *options,
|
||||
bool keep_old_opts);
|
||||
int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp);
|
||||
int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
|
||||
Error **errp);
|
||||
int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
|
||||
@ -353,6 +357,11 @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
|
||||
BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
|
||||
BlockDriverState *bs);
|
||||
BlockDriverState *bdrv_find_base(BlockDriverState *bs);
|
||||
bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
|
||||
Error **errp);
|
||||
int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
|
||||
Error **errp);
|
||||
void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base);
|
||||
|
||||
|
||||
typedef struct BdrvCheckResult {
|
||||
|
||||
@ -383,6 +383,14 @@ struct BlockDriver {
|
||||
|
||||
/* List of options for creating images, terminated by name == NULL */
|
||||
QemuOptsList *create_opts;
|
||||
/*
|
||||
* If this driver supports reopening images this contains a
|
||||
* NULL-terminated list of the runtime options that can be
|
||||
* modified. If an option in this list is unspecified during
|
||||
* reopen then it _must_ be reset to its default value or return
|
||||
* an error.
|
||||
*/
|
||||
const char *const *mutable_opts;
|
||||
|
||||
/*
|
||||
* Returns 0 for completed check, -errno for internal errors.
|
||||
@ -711,6 +719,12 @@ struct BdrvChild {
|
||||
uint64_t backup_perm;
|
||||
uint64_t backup_shared_perm;
|
||||
|
||||
/*
|
||||
* This link is frozen: the child can neither be replaced nor
|
||||
* detached from the parent.
|
||||
*/
|
||||
bool frozen;
|
||||
|
||||
QLIST_ENTRY(BdrvChild) next;
|
||||
QLIST_ENTRY(BdrvChild) next_parent;
|
||||
};
|
||||
|
||||
@ -537,20 +537,20 @@
|
||||
# +------------------
|
||||
# 10 50 100
|
||||
#
|
||||
# Since: 2.12
|
||||
# Since: 4.0
|
||||
##
|
||||
{ 'struct': 'BlockLatencyHistogramInfo',
|
||||
'data': {'boundaries': ['uint64'], 'bins': ['uint64'] } }
|
||||
|
||||
##
|
||||
# @x-block-latency-histogram-set:
|
||||
# @block-latency-histogram-set:
|
||||
#
|
||||
# Manage read, write and flush latency histograms for the device.
|
||||
#
|
||||
# If only @device parameter is specified, remove all present latency histograms
|
||||
# for the device. Otherwise, add/reset some of (or all) latency histograms.
|
||||
#
|
||||
# @device: device name to set latency histogram for.
|
||||
# @id: The name or QOM path of the guest device.
|
||||
#
|
||||
# @boundaries: list of interval boundary values (see description in
|
||||
# BlockLatencyHistogramInfo definition). If specified, all
|
||||
@ -573,7 +573,7 @@
|
||||
#
|
||||
# Returns: error if device is not found or any boundary arrays are invalid.
|
||||
#
|
||||
# Since: 2.12
|
||||
# Since: 4.0
|
||||
#
|
||||
# Example: set new histograms for all io types with intervals
|
||||
# [0, 10), [10, 50), [50, 100), [100, +inf):
|
||||
@ -607,8 +607,8 @@
|
||||
# "arguments": { "device": "drive0" } }
|
||||
# <- { "return": {} }
|
||||
##
|
||||
{ 'command': 'x-block-latency-histogram-set',
|
||||
'data': {'device': 'str',
|
||||
{ 'command': 'block-latency-histogram-set',
|
||||
'data': {'id': 'str',
|
||||
'*boundaries': ['uint64'],
|
||||
'*boundaries-read': ['uint64'],
|
||||
'*boundaries-write': ['uint64'],
|
||||
@ -894,11 +894,11 @@
|
||||
# @timed_stats: Statistics specific to the set of previously defined
|
||||
# intervals of time (Since 2.5)
|
||||
#
|
||||
# @x_rd_latency_histogram: @BlockLatencyHistogramInfo. (Since 2.12)
|
||||
# @rd_latency_histogram: @BlockLatencyHistogramInfo. (Since 4.0)
|
||||
#
|
||||
# @x_wr_latency_histogram: @BlockLatencyHistogramInfo. (Since 2.12)
|
||||
# @wr_latency_histogram: @BlockLatencyHistogramInfo. (Since 4.0)
|
||||
#
|
||||
# @x_flush_latency_histogram: @BlockLatencyHistogramInfo. (Since 2.12)
|
||||
# @flush_latency_histogram: @BlockLatencyHistogramInfo. (Since 4.0)
|
||||
#
|
||||
# Since: 0.14.0
|
||||
##
|
||||
@ -913,9 +913,9 @@
|
||||
'invalid_wr_operations': 'int', 'invalid_flush_operations': 'int',
|
||||
'account_invalid': 'bool', 'account_failed': 'bool',
|
||||
'timed_stats': ['BlockDeviceTimedStats'],
|
||||
'*x_rd_latency_histogram': 'BlockLatencyHistogramInfo',
|
||||
'*x_wr_latency_histogram': 'BlockLatencyHistogramInfo',
|
||||
'*x_flush_latency_histogram': 'BlockLatencyHistogramInfo' } }
|
||||
'*rd_latency_histogram': 'BlockLatencyHistogramInfo',
|
||||
'*wr_latency_histogram': 'BlockLatencyHistogramInfo',
|
||||
'*flush_latency_histogram': 'BlockLatencyHistogramInfo' } }
|
||||
|
||||
##
|
||||
# @BlockStats:
|
||||
@ -3997,6 +3997,48 @@
|
||||
##
|
||||
{ 'command': 'blockdev-add', 'data': 'BlockdevOptions', 'boxed': true }
|
||||
|
||||
##
|
||||
# @x-blockdev-reopen:
|
||||
#
|
||||
# Reopens a block device using the given set of options. Any option
|
||||
# not specified will be reset to its default value regardless of its
|
||||
# previous status. If an option cannot be changed or a particular
|
||||
# driver does not support reopening then the command will return an
|
||||
# error.
|
||||
#
|
||||
# The top-level @node-name option (from BlockdevOptions) must be
|
||||
# specified and is used to select the block device to be reopened.
|
||||
# Other @node-name options must be either omitted or set to the
|
||||
# current name of the appropriate node. This command won't change any
|
||||
# node name and any attempt to do it will result in an error.
|
||||
#
|
||||
# In the case of options that refer to child nodes, the behavior of
|
||||
# this command depends on the value:
|
||||
#
|
||||
# 1) A set of options (BlockdevOptions): the child is reopened with
|
||||
# the specified set of options.
|
||||
#
|
||||
# 2) A reference to the current child: the child is reopened using
|
||||
# its existing set of options.
|
||||
#
|
||||
# 3) A reference to a different node: the current child is replaced
|
||||
# with the specified one.
|
||||
#
|
||||
# 4) NULL: the current child (if any) is detached.
|
||||
#
|
||||
# Options (1) and (2) are supported in all cases, but at the moment
|
||||
# only @backing allows replacing or detaching an existing child.
|
||||
#
|
||||
# Unlike with blockdev-add, the @backing option must always be present
|
||||
# unless the node being reopened does not have a backing file and its
|
||||
# image does not have a default backing file name as part of its
|
||||
# metadata.
|
||||
#
|
||||
# Since: 4.0
|
||||
##
|
||||
{ 'command': 'x-blockdev-reopen',
|
||||
'data': 'BlockdevOptions', 'boxed': true }
|
||||
|
||||
##
|
||||
# @blockdev-del:
|
||||
#
|
||||
|
||||
@ -2080,8 +2080,8 @@ static int reopen_f(BlockBackend *blk, int argc, char **argv)
|
||||
}
|
||||
|
||||
bdrv_subtree_drained_begin(bs);
|
||||
brq = bdrv_reopen_queue(NULL, bs, opts);
|
||||
bdrv_reopen_multiple(bdrv_get_aio_context(bs), brq, &local_err);
|
||||
brq = bdrv_reopen_queue(NULL, bs, opts, true);
|
||||
bdrv_reopen_multiple(brq, &local_err);
|
||||
bdrv_subtree_drained_end(bs);
|
||||
|
||||
if (local_err) {
|
||||
|
||||
@ -356,6 +356,13 @@ $QEMU_IO -c "read -P 0x33 0 4k" "$TEST_IMG" | _filter_qemu_io
|
||||
# Using snapshot=on with a non-existent TMPDIR
|
||||
TMPDIR=/nonexistent run_qemu -drive driver=null-co,snapshot=on
|
||||
|
||||
# Using snapshot=on together with read-only=on
|
||||
echo "info block" |
|
||||
run_qemu -drive file="$TEST_IMG",snapshot=on,read-only=on,if=none,id=$device_id |
|
||||
_filter_qemu_io |
|
||||
sed -e 's#"/[^"]*/vl\.[A-Za-z0-9]\{6\}"#SNAPSHOT_PATH#g'
|
||||
|
||||
|
||||
# success, all done
|
||||
echo "*** done"
|
||||
rm -f $seq.full
|
||||
|
||||
@ -458,4 +458,13 @@ read 4096/4096 bytes at offset 0
|
||||
Testing: -drive driver=null-co,snapshot=on
|
||||
QEMU_PROG: -drive driver=null-co,snapshot=on: Could not get temporary filename: No such file or directory
|
||||
|
||||
Testing: -drive file=TEST_DIR/t.qcow2,snapshot=on,read-only=on,if=none,id=drive0
|
||||
QEMU X.Y.Z monitor - type 'help' for more information
|
||||
(qemu) info block
|
||||
drive0 (NODE_NAME): json:{"backing": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/t.qcow2"}}, "driver": "qcow2", "file": {"driver": "file", "filename": SNAPSHOT_PATH}} (qcow2, read-only)
|
||||
Removable device: not locked, tray closed
|
||||
Cache mode: writeback, ignore flushes
|
||||
Backing file: TEST_DIR/t.qcow2 (chain depth: 1)
|
||||
(qemu) quit
|
||||
|
||||
*** done
|
||||
|
||||
@ -530,4 +530,13 @@ read 4096/4096 bytes at offset 0
|
||||
Testing: -drive driver=null-co,snapshot=on
|
||||
QEMU_PROG: -drive driver=null-co,snapshot=on: Could not get temporary filename: No such file or directory
|
||||
|
||||
Testing: -drive file=TEST_DIR/t.qcow2,snapshot=on,read-only=on,if=none,id=drive0
|
||||
QEMU X.Y.Z monitor - type 'help' for more information
|
||||
(qemu) info block
|
||||
drive0 (NODE_NAME): json:{"backing": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/t.qcow2"}}, "driver": "qcow2", "file": {"driver": "file", "filename": SNAPSHOT_PATH}} (qcow2, read-only)
|
||||
Removable device: not locked, tray closed
|
||||
Cache mode: writeback, ignore flushes
|
||||
Backing file: TEST_DIR/t.qcow2 (chain depth: 1)
|
||||
(qemu) quit
|
||||
|
||||
*** done
|
||||
|
||||
@ -29,6 +29,7 @@ status=1 # failure is the default!
|
||||
_cleanup()
|
||||
{
|
||||
_cleanup_test_img
|
||||
rm -f $TEST_IMG.[01234]
|
||||
}
|
||||
trap "_cleanup; exit \$status" 0 1 2 3 15
|
||||
|
||||
@ -143,6 +144,36 @@ run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,a
|
||||
run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=on
|
||||
run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0
|
||||
|
||||
echo
|
||||
echo "=== Try commit to backing file with auto-read-only ==="
|
||||
echo
|
||||
|
||||
TEST_IMG="$TEST_IMG.0" _make_test_img $size
|
||||
TEST_IMG="$TEST_IMG.1" _make_test_img $size
|
||||
TEST_IMG="$TEST_IMG.2" _make_test_img $size
|
||||
TEST_IMG="$TEST_IMG.3" _make_test_img $size
|
||||
TEST_IMG="$TEST_IMG.4" _make_test_img $size
|
||||
|
||||
(cat <<EOF
|
||||
{"execute":"qmp_capabilities"}
|
||||
{"execute":"block-commit",
|
||||
"arguments":{"device":"format-4", "top-node": "format-2", "base-node":"format-0", "job-id":"job0"}}
|
||||
EOF
|
||||
sleep 1
|
||||
echo '{"execute":"quit"}'
|
||||
) | $QEMU -qmp stdio -nographic -nodefaults \
|
||||
-blockdev file,node-name=file-0,filename=$TEST_IMG.0,auto-read-only=on \
|
||||
-blockdev qcow2,node-name=format-0,file=file-0,read-only=on \
|
||||
-blockdev file,node-name=file-1,filename=$TEST_IMG.1,auto-read-only=on \
|
||||
-blockdev qcow2,node-name=format-1,file=file-1,read-only=on,backing=format-0 \
|
||||
-blockdev file,node-name=file-2,filename=$TEST_IMG.2,auto-read-only=on \
|
||||
-blockdev qcow2,node-name=format-2,file=file-2,read-only=on,backing=format-1 \
|
||||
-blockdev file,node-name=file-3,filename=$TEST_IMG.3,auto-read-only=on \
|
||||
-blockdev qcow2,node-name=format-3,file=file-3,read-only=on,backing=format-2 \
|
||||
-blockdev file,node-name=file-4,filename=$TEST_IMG.4,auto-read-only=on \
|
||||
-blockdev qcow2,node-name=format-4,file=file-4,read-only=on,backing=format-3 |
|
||||
_filter_qmp
|
||||
|
||||
# success, all done
|
||||
echo "*** done"
|
||||
rm -f $seq.full
|
||||
|
||||
@ -22,12 +22,12 @@ NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
|
||||
QEMU_PROG: -drive driver=file,file=TEST_DIR/t.IMGFMT,if=none,read-only=off,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file)
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file)
|
||||
|
||||
QEMU_PROG: -drive driver=file,file=TEST_DIR/t.IMGFMT,if=none,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file)
|
||||
NODE_NAME: TEST_DIR/t.IMGFMT (file)
|
||||
|
||||
=== -blockdev with read-write image: read-only/auto-read-only combinations ===
|
||||
|
||||
@ -50,10 +50,30 @@ node0: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
node0: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
|
||||
QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,read-only=off,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
|
||||
node0: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
node0: TEST_DIR/t.IMGFMT (file)
|
||||
QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
|
||||
|
||||
QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
|
||||
node0: TEST_DIR/t.IMGFMT (file, read-only)
|
||||
node0: TEST_DIR/t.IMGFMT (file)
|
||||
QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0: Could not open 'TEST_DIR/t.IMGFMT': Permission denied
|
||||
|
||||
=== Try commit to backing file with auto-read-only ===
|
||||
|
||||
Formatting 'TEST_DIR/t.IMGFMT.0', fmt=IMGFMT size=134217728
|
||||
Formatting 'TEST_DIR/t.IMGFMT.1', fmt=IMGFMT size=134217728
|
||||
Formatting 'TEST_DIR/t.IMGFMT.2', fmt=IMGFMT size=134217728
|
||||
Formatting 'TEST_DIR/t.IMGFMT.3', fmt=IMGFMT size=134217728
|
||||
Formatting 'TEST_DIR/t.IMGFMT.4', fmt=IMGFMT size=134217728
|
||||
QMP_VERSION
|
||||
{"return": {}}
|
||||
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}
|
||||
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}
|
||||
{"return": {}}
|
||||
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "job0"}}
|
||||
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "pending", "id": "job0"}}
|
||||
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "job0", "len": 134217728, "offset": 134217728, "speed": 0, "type": "commit"}}
|
||||
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "concluded", "id": "job0"}}
|
||||
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "null", "id": "job0"}}
|
||||
{"return": {}}
|
||||
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false, "reason": "host-qmp-quit"}}
|
||||
*** done
|
||||
|
||||
991
tests/qemu-iotests/245
Normal file
991
tests/qemu-iotests/245
Normal file
@ -0,0 +1,991 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# Test cases for the QMP 'x-blockdev-reopen' command
|
||||
#
|
||||
# Copyright (C) 2018-2019 Igalia, S.L.
|
||||
# Author: Alberto Garcia <berto@igalia.com>
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
|
||||
import os
|
||||
import re
|
||||
import iotests
|
||||
import copy
|
||||
import json
|
||||
from iotests import qemu_img, qemu_io
|
||||
|
||||
hd_path = [
|
||||
os.path.join(iotests.test_dir, 'hd0.img'),
|
||||
os.path.join(iotests.test_dir, 'hd1.img'),
|
||||
os.path.join(iotests.test_dir, 'hd2.img')
|
||||
]
|
||||
|
||||
def hd_opts(idx):
|
||||
return {'driver': iotests.imgfmt,
|
||||
'node-name': 'hd%d' % idx,
|
||||
'file': {'driver': 'file',
|
||||
'node-name': 'hd%d-file' % idx,
|
||||
'filename': hd_path[idx] } }
|
||||
|
||||
class TestBlockdevReopen(iotests.QMPTestCase):
|
||||
total_io_cmds = 0
|
||||
|
||||
def setUp(self):
|
||||
qemu_img('create', '-f', iotests.imgfmt, hd_path[0], '3M')
|
||||
qemu_img('create', '-f', iotests.imgfmt, '-b', hd_path[0], hd_path[1])
|
||||
qemu_img('create', '-f', iotests.imgfmt, hd_path[2], '3M')
|
||||
qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa0 0 1M', hd_path[0])
|
||||
qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa1 1M 1M', hd_path[1])
|
||||
qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa2 2M 1M', hd_path[2])
|
||||
self.vm = iotests.VM()
|
||||
self.vm.launch()
|
||||
|
||||
def tearDown(self):
|
||||
self.vm.shutdown()
|
||||
self.check_qemu_io_errors()
|
||||
os.remove(hd_path[0])
|
||||
os.remove(hd_path[1])
|
||||
os.remove(hd_path[2])
|
||||
|
||||
# The output of qemu-io is not returned by vm.hmp_qemu_io() but
|
||||
# it's stored in the log and can only be read when the VM has been
|
||||
# shut down. This function runs qemu-io and keeps track of the
|
||||
# number of times it's been called.
|
||||
def run_qemu_io(self, img, cmd):
|
||||
result = self.vm.hmp_qemu_io(img, cmd)
|
||||
self.assert_qmp(result, 'return', '')
|
||||
self.total_io_cmds += 1
|
||||
|
||||
# Once the VM is shut down we can parse the log and see if qemu-io
|
||||
# ran without errors.
|
||||
def check_qemu_io_errors(self):
|
||||
self.assertFalse(self.vm.is_running())
|
||||
found = 0
|
||||
log = self.vm.get_log()
|
||||
for line in log.split("\n"):
|
||||
if line.startswith("Pattern verification failed"):
|
||||
raise Exception("%s (command #%d)" % (line, found))
|
||||
if re.match("read .*/.* bytes at offset", line):
|
||||
found += 1
|
||||
self.assertEqual(found, self.total_io_cmds,
|
||||
"Expected output of %d qemu-io commands, found %d" %
|
||||
(found, self.total_io_cmds))
|
||||
|
||||
# Run x-blockdev-reopen with 'opts' but applying 'newopts'
|
||||
# on top of it. The original 'opts' dict is unmodified
|
||||
def reopen(self, opts, newopts = {}, errmsg = None):
|
||||
opts = copy.deepcopy(opts)
|
||||
|
||||
# Apply the changes from 'newopts' on top of 'opts'
|
||||
for key in newopts:
|
||||
value = newopts[key]
|
||||
# If key has the form "foo.bar" then we need to do
|
||||
# opts["foo"]["bar"] = value, not opts["foo.bar"] = value
|
||||
subdict = opts
|
||||
while key.find('.') != -1:
|
||||
[prefix, key] = key.split('.', 1)
|
||||
subdict = opts[prefix]
|
||||
subdict[key] = value
|
||||
|
||||
result = self.vm.qmp('x-blockdev-reopen', conv_keys = False, **opts)
|
||||
if errmsg:
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
self.assert_qmp(result, 'error/desc', errmsg)
|
||||
else:
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
|
||||
# Run query-named-block-nodes and return the specified entry
|
||||
def get_node(self, node_name):
|
||||
result = self.vm.qmp('query-named-block-nodes')
|
||||
for node in result['return']:
|
||||
if node['node-name'] == node_name:
|
||||
return node
|
||||
return None
|
||||
|
||||
# Run 'query-named-block-nodes' and compare its output with the
|
||||
# value passed by the user in 'graph'
|
||||
def check_node_graph(self, graph):
|
||||
result = self.vm.qmp('query-named-block-nodes')
|
||||
self.assertEqual(json.dumps(graph, sort_keys=True),
|
||||
json.dumps(result, sort_keys=True))
|
||||
|
||||
# This test opens one single disk image (without backing files)
|
||||
# and tries to reopen it with illegal / incorrect parameters.
|
||||
def test_incorrect_parameters_single_file(self):
|
||||
# Open 'hd0' only (no backing files)
|
||||
opts = hd_opts(0)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
original_graph = self.vm.qmp('query-named-block-nodes')
|
||||
|
||||
# We can reopen the image passing the same options
|
||||
self.reopen(opts)
|
||||
|
||||
# We can also reopen passing a child reference in 'file'
|
||||
self.reopen(opts, {'file': 'hd0-file'})
|
||||
|
||||
# We cannot change any of these
|
||||
self.reopen(opts, {'node-name': 'not-found'}, "Cannot find node named 'not-found'")
|
||||
self.reopen(opts, {'node-name': ''}, "Cannot find node named ''")
|
||||
self.reopen(opts, {'node-name': None}, "Invalid parameter type for 'node-name', expected: string")
|
||||
self.reopen(opts, {'driver': 'raw'}, "Cannot change the option 'driver'")
|
||||
self.reopen(opts, {'driver': ''}, "Invalid parameter ''")
|
||||
self.reopen(opts, {'driver': None}, "Invalid parameter type for 'driver', expected: string")
|
||||
self.reopen(opts, {'file': 'not-found'}, "Cannot change the option 'file'")
|
||||
self.reopen(opts, {'file': ''}, "Cannot change the option 'file'")
|
||||
self.reopen(opts, {'file': None}, "Invalid parameter type for 'file', expected: BlockdevRef")
|
||||
self.reopen(opts, {'file.node-name': 'newname'}, "Cannot change the option 'node-name'")
|
||||
self.reopen(opts, {'file.driver': 'host_device'}, "Cannot change the option 'driver'")
|
||||
self.reopen(opts, {'file.filename': hd_path[1]}, "Cannot change the option 'filename'")
|
||||
self.reopen(opts, {'file.aio': 'native'}, "Cannot change the option 'aio'")
|
||||
self.reopen(opts, {'file.locking': 'off'}, "Cannot change the option 'locking'")
|
||||
self.reopen(opts, {'file.filename': None}, "Invalid parameter type for 'file.filename', expected: string")
|
||||
|
||||
# node-name is optional in BlockdevOptions, but x-blockdev-reopen needs it
|
||||
del opts['node-name']
|
||||
self.reopen(opts, {}, "Node name not specified")
|
||||
|
||||
# Check that nothing has changed
|
||||
self.check_node_graph(original_graph)
|
||||
|
||||
# Remove the node
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# This test opens an image with a backing file and tries to reopen
|
||||
# it with illegal / incorrect parameters.
|
||||
def test_incorrect_parameters_backing_file(self):
|
||||
# Open hd1 omitting the backing options (hd0 will be opened
|
||||
# with the default options)
|
||||
opts = hd_opts(1)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
original_graph = self.vm.qmp('query-named-block-nodes')
|
||||
|
||||
# We can't reopen the image passing the same options, 'backing' is mandatory
|
||||
self.reopen(opts, {}, "backing is missing for 'hd1'")
|
||||
|
||||
# Everything works if we pass 'backing' using the existing node name
|
||||
for node in original_graph['return']:
|
||||
if node['drv'] == iotests.imgfmt and node['file'] == hd_path[0]:
|
||||
backing_node_name = node['node-name']
|
||||
self.reopen(opts, {'backing': backing_node_name})
|
||||
|
||||
# We can't use a non-existing or empty (non-NULL) node as the backing image
|
||||
self.reopen(opts, {'backing': 'not-found'}, "Cannot find device= nor node_name=not-found")
|
||||
self.reopen(opts, {'backing': ''}, "Cannot find device= nor node_name=")
|
||||
|
||||
# We can reopen the image just fine if we specify the backing options
|
||||
opts['backing'] = {'driver': iotests.imgfmt,
|
||||
'file': {'driver': 'file',
|
||||
'filename': hd_path[0]}}
|
||||
self.reopen(opts)
|
||||
|
||||
# We cannot change any of these options
|
||||
self.reopen(opts, {'backing.node-name': 'newname'}, "Cannot change the option 'node-name'")
|
||||
self.reopen(opts, {'backing.driver': 'raw'}, "Cannot change the option 'driver'")
|
||||
self.reopen(opts, {'backing.file.node-name': 'newname'}, "Cannot change the option 'node-name'")
|
||||
self.reopen(opts, {'backing.file.driver': 'host_device'}, "Cannot change the option 'driver'")
|
||||
|
||||
# Check that nothing has changed since the beginning
|
||||
self.check_node_graph(original_graph)
|
||||
|
||||
# Remove the node
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Reopen an image several times changing some of its options
|
||||
def test_reopen(self):
|
||||
# Open the hd1 image passing all backing options
|
||||
opts = hd_opts(1)
|
||||
opts['backing'] = hd_opts(0)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
original_graph = self.vm.qmp('query-named-block-nodes')
|
||||
|
||||
# We can reopen the image passing the same options
|
||||
self.reopen(opts)
|
||||
|
||||
# Reopen in read-only mode
|
||||
self.assert_qmp(self.get_node('hd1'), 'ro', False)
|
||||
|
||||
self.reopen(opts, {'read-only': True})
|
||||
self.assert_qmp(self.get_node('hd1'), 'ro', True)
|
||||
self.reopen(opts)
|
||||
self.assert_qmp(self.get_node('hd1'), 'ro', False)
|
||||
|
||||
# Change the cache options
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/direct', False)
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', False)
|
||||
self.reopen(opts, {'cache': { 'direct': True, 'no-flush': True }})
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/direct', True)
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', True)
|
||||
|
||||
# Reopen again with the original options
|
||||
self.reopen(opts)
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/direct', False)
|
||||
self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', False)
|
||||
|
||||
# Change 'detect-zeroes' and 'discard'
|
||||
self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'off')
|
||||
self.reopen(opts, {'detect-zeroes': 'on'})
|
||||
self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
|
||||
self.reopen(opts, {'detect-zeroes': 'unmap'},
|
||||
"setting detect-zeroes to unmap is not allowed " +
|
||||
"without setting discard operation to unmap")
|
||||
self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
|
||||
self.reopen(opts, {'detect-zeroes': 'unmap', 'discard': 'unmap'})
|
||||
self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'unmap')
|
||||
self.reopen(opts)
|
||||
self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'off')
|
||||
|
||||
# Changing 'force-share' is currently not supported
|
||||
self.reopen(opts, {'force-share': True}, "Cannot change the option 'force-share'")
|
||||
|
||||
# Change some qcow2-specific options
|
||||
# No way to test for success other than checking the return message
|
||||
if iotests.imgfmt == 'qcow2':
|
||||
self.reopen(opts, {'l2-cache-entry-size': 128 * 1024},
|
||||
"L2 cache entry size must be a power of two "+
|
||||
"between 512 and the cluster size (65536)")
|
||||
self.reopen(opts, {'l2-cache-size': 1024 * 1024,
|
||||
'cache-size': 512 * 1024},
|
||||
"l2-cache-size may not exceed cache-size")
|
||||
self.reopen(opts, {'l2-cache-size': 4 * 1024 * 1024,
|
||||
'refcount-cache-size': 4 * 1024 * 1024,
|
||||
'l2-cache-entry-size': 32 * 1024})
|
||||
self.reopen(opts, {'pass-discard-request': True})
|
||||
|
||||
# Check that nothing has changed since the beginning
|
||||
# (from the parameters that we can check)
|
||||
self.check_node_graph(original_graph)
|
||||
|
||||
# Check that the node names (other than the top-level one) are optional
|
||||
del opts['file']['node-name']
|
||||
del opts['backing']['node-name']
|
||||
del opts['backing']['file']['node-name']
|
||||
self.reopen(opts)
|
||||
self.check_node_graph(original_graph)
|
||||
|
||||
# Reopen setting backing = null, this removes the backing image from the chain
|
||||
self.reopen(opts, {'backing': None})
|
||||
self.assert_qmp_absent(self.get_node('hd1'), 'image/backing-image')
|
||||
|
||||
# Open the 'hd0' image
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **hd_opts(0))
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Reopen the hd1 image setting 'hd0' as its backing image
|
||||
self.reopen(opts, {'backing': 'hd0'})
|
||||
self.assert_qmp(self.get_node('hd1'), 'image/backing-image/filename', hd_path[0])
|
||||
|
||||
# Check that nothing has changed since the beginning
|
||||
self.reopen(hd_opts(0), {'read-only': True})
|
||||
self.check_node_graph(original_graph)
|
||||
|
||||
# The backing file (hd0) is now a reference, we cannot change backing.* anymore
|
||||
self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
|
||||
|
||||
# We can't remove 'hd0' while it's a backing image of 'hd1'
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
self.assert_qmp(result, 'error/desc', "Node 'hd0' is busy: node is used as backing hd of 'hd1'")
|
||||
|
||||
# But we can remove both nodes if done in the proper order
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Reopen a raw image and see the effect of changing the 'offset' option
|
||||
def test_reopen_raw(self):
|
||||
opts = {'driver': 'raw', 'node-name': 'hd0',
|
||||
'file': { 'driver': 'file',
|
||||
'filename': hd_path[0],
|
||||
'node-name': 'hd0-file' } }
|
||||
|
||||
# First we create a 2MB raw file, and fill each half with a
|
||||
# different value
|
||||
qemu_img('create', '-f', 'raw', hd_path[0], '2M')
|
||||
qemu_io('-f', 'raw', '-c', 'write -P 0xa0 0 1M', hd_path[0])
|
||||
qemu_io('-f', 'raw', '-c', 'write -P 0xa1 1M 1M', hd_path[0])
|
||||
|
||||
# Open the raw file with QEMU
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Read 1MB from offset 0
|
||||
self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
|
||||
|
||||
# Reopen the image with a 1MB offset.
|
||||
# Now the results are different
|
||||
self.reopen(opts, {'offset': 1024*1024})
|
||||
self.run_qemu_io("hd0", "read -P 0xa1 0 1M")
|
||||
|
||||
# Reopen again with the original options.
|
||||
# We get the original results again
|
||||
self.reopen(opts)
|
||||
self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
|
||||
|
||||
# Remove the block device
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Omitting an option should reset it to the default value, but if
|
||||
# an option cannot be changed it shouldn't be possible to reset it
|
||||
# to its default value either
|
||||
def test_reset_default_values(self):
|
||||
opts = {'driver': 'qcow2', 'node-name': 'hd0',
|
||||
'file': { 'driver': 'file',
|
||||
'filename': hd_path[0],
|
||||
'x-check-cache-dropped': True, # This one can be changed
|
||||
'locking': 'off', # This one can NOT be changed
|
||||
'node-name': 'hd0-file' } }
|
||||
|
||||
# Open the file with QEMU
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# file.x-check-cache-dropped can be changed...
|
||||
self.reopen(opts, { 'file.x-check-cache-dropped': False })
|
||||
# ...and dropped completely (resetting to the default value)
|
||||
del opts['file']['x-check-cache-dropped']
|
||||
self.reopen(opts)
|
||||
|
||||
# file.locking cannot be changed nor reset to the default value
|
||||
self.reopen(opts, { 'file.locking': 'on' }, "Cannot change the option 'locking'")
|
||||
del opts['file']['locking']
|
||||
self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
|
||||
# But we can reopen it if we maintain its previous value
|
||||
self.reopen(opts, { 'file.locking': 'off' })
|
||||
|
||||
# Remove the block device
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# This test modifies the node graph a few times by changing the
|
||||
# 'backing' option on reopen and verifies that the guest data that
|
||||
# is read afterwards is consistent with the graph changes.
|
||||
def test_io_with_graph_changes(self):
|
||||
opts = []
|
||||
|
||||
# Open hd0, hd1 and hd2 without any backing image
|
||||
for i in range(3):
|
||||
opts.append(hd_opts(i))
|
||||
opts[i]['backing'] = None
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts[i])
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# hd0
|
||||
self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0 1M 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0 2M 1M")
|
||||
|
||||
# hd1 <- hd0
|
||||
self.reopen(opts[0], {'backing': 'hd1'})
|
||||
|
||||
self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0 2M 1M")
|
||||
|
||||
# hd1 <- hd0 , hd1 <- hd2
|
||||
self.reopen(opts[2], {'backing': 'hd1'})
|
||||
|
||||
self.run_qemu_io("hd2", "read -P 0 0 1M")
|
||||
self.run_qemu_io("hd2", "read -P 0xa1 1M 1M")
|
||||
self.run_qemu_io("hd2", "read -P 0xa2 2M 1M")
|
||||
|
||||
# hd1 <- hd2 <- hd0
|
||||
self.reopen(opts[0], {'backing': 'hd2'})
|
||||
|
||||
self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
|
||||
|
||||
# hd2 <- hd0
|
||||
self.reopen(opts[2], {'backing': None})
|
||||
|
||||
self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0 1M 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
|
||||
|
||||
# hd2 <- hd1 <- hd0
|
||||
self.reopen(opts[1], {'backing': 'hd2'})
|
||||
self.reopen(opts[0], {'backing': 'hd1'})
|
||||
|
||||
self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
|
||||
self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
|
||||
|
||||
# Illegal operation: hd2 is a child of hd1
|
||||
self.reopen(opts[2], {'backing': 'hd1'},
|
||||
"Making 'hd1' a backing file of 'hd2' would create a cycle")
|
||||
|
||||
# hd2 <- hd0, hd2 <- hd1
|
||||
self.reopen(opts[0], {'backing': 'hd2'})
|
||||
|
||||
self.run_qemu_io("hd1", "read -P 0 0 1M")
|
||||
self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
|
||||
self.run_qemu_io("hd1", "read -P 0xa2 2M 1M")
|
||||
|
||||
# More illegal operations
|
||||
self.reopen(opts[2], {'backing': 'hd1'},
|
||||
"Making 'hd1' a backing file of 'hd2' would create a cycle")
|
||||
self.reopen(opts[2], {'file': 'hd0-file'}, "Cannot change the option 'file'")
|
||||
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
self.assert_qmp(result, 'error/desc', "Node 'hd2' is busy: node is used as backing hd of 'hd0'")
|
||||
|
||||
# hd1 doesn't have a backing file now
|
||||
self.reopen(opts[1], {'backing': None})
|
||||
|
||||
self.run_qemu_io("hd1", "read -P 0 0 1M")
|
||||
self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
|
||||
self.run_qemu_io("hd1", "read -P 0 2M 1M")
|
||||
|
||||
# We can't remove the 'backing' option if the image has a
|
||||
# default backing file
|
||||
del opts[1]['backing']
|
||||
self.reopen(opts[1], {}, "backing is missing for 'hd1'")
|
||||
|
||||
self.run_qemu_io("hd1", "read -P 0 0 1M")
|
||||
self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
|
||||
self.run_qemu_io("hd1", "read -P 0 2M 1M")
|
||||
|
||||
# This test verifies that we can't change the children of a block
|
||||
# device during a reopen operation in a way that would create
|
||||
# cycles in the node graph
|
||||
def test_graph_cycles(self):
|
||||
opts = []
|
||||
|
||||
# Open all three images without backing file
|
||||
for i in range(3):
|
||||
opts.append(hd_opts(i))
|
||||
opts[i]['backing'] = None
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts[i])
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# hd1 <- hd0, hd1 <- hd2
|
||||
self.reopen(opts[0], {'backing': 'hd1'})
|
||||
self.reopen(opts[2], {'backing': 'hd1'})
|
||||
|
||||
# Illegal: hd2 is backed by hd1
|
||||
self.reopen(opts[1], {'backing': 'hd2'},
|
||||
"Making 'hd2' a backing file of 'hd1' would create a cycle")
|
||||
|
||||
# hd1 <- hd0 <- hd2
|
||||
self.reopen(opts[2], {'backing': 'hd0'})
|
||||
|
||||
# Illegal: hd2 is backed by hd0, which is backed by hd1
|
||||
self.reopen(opts[1], {'backing': 'hd2'},
|
||||
"Making 'hd2' a backing file of 'hd1' would create a cycle")
|
||||
|
||||
# Illegal: hd1 cannot point to itself
|
||||
self.reopen(opts[1], {'backing': 'hd1'},
|
||||
"Making 'hd1' a backing file of 'hd1' would create a cycle")
|
||||
|
||||
# Remove all backing files
|
||||
self.reopen(opts[0])
|
||||
self.reopen(opts[2])
|
||||
|
||||
##########################################
|
||||
# Add a blkverify node using hd0 and hd1 #
|
||||
##########################################
|
||||
bvopts = {'driver': 'blkverify',
|
||||
'node-name': 'bv',
|
||||
'test': 'hd0',
|
||||
'raw': 'hd1'}
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **bvopts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# blkverify doesn't currently allow reopening. TODO: implement this
|
||||
self.reopen(bvopts, {}, "Block format 'blkverify' used by node 'bv'" +
|
||||
" does not support reopening files")
|
||||
|
||||
# Illegal: hd0 is a child of the blkverify node
|
||||
self.reopen(opts[0], {'backing': 'bv'},
|
||||
"Making 'bv' a backing file of 'hd0' would create a cycle")
|
||||
|
||||
# Delete the blkverify node
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'bv')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Misc reopen tests with different block drivers
|
||||
def test_misc_drivers(self):
|
||||
####################
|
||||
###### quorum ######
|
||||
####################
|
||||
for i in range(3):
|
||||
opts = hd_opts(i)
|
||||
# Open all three images without backing file
|
||||
opts['backing'] = None
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
opts = {'driver': 'quorum',
|
||||
'node-name': 'quorum0',
|
||||
'children': ['hd0', 'hd1', 'hd2'],
|
||||
'vote-threshold': 2}
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Quorum doesn't currently allow reopening. TODO: implement this
|
||||
self.reopen(opts, {}, "Block format 'quorum' used by node 'quorum0'" +
|
||||
" does not support reopening files")
|
||||
|
||||
# You can't make quorum0 a backing file of hd0:
|
||||
# hd0 is already a child of quorum0.
|
||||
self.reopen(hd_opts(0), {'backing': 'quorum0'},
|
||||
"Making 'quorum0' a backing file of 'hd0' would create a cycle")
|
||||
|
||||
# Delete quorum0
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'quorum0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Delete hd0, hd1 and hd2
|
||||
for i in range(3):
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True,
|
||||
node_name = 'hd%d' % i)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
######################
|
||||
###### blkdebug ######
|
||||
######################
|
||||
opts = {'driver': 'blkdebug',
|
||||
'node-name': 'bd',
|
||||
'config': '/dev/null',
|
||||
'image': hd_opts(0)}
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# blkdebug allows reopening if we keep the same options
|
||||
self.reopen(opts)
|
||||
|
||||
# but it currently does not allow changes
|
||||
self.reopen(opts, {'image': 'hd1'}, "Cannot change the option 'image'")
|
||||
self.reopen(opts, {'align': 33554432}, "Cannot change the option 'align'")
|
||||
self.reopen(opts, {'config': '/non/existent'}, "Cannot change the option 'config'")
|
||||
del opts['config']
|
||||
self.reopen(opts, {}, "Option 'config' cannot be reset to its default value")
|
||||
|
||||
# Delete the blkdebug node
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'bd')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
##################
|
||||
###### null ######
|
||||
##################
|
||||
opts = {'driver': 'null-aio', 'node-name': 'root', 'size': 1024}
|
||||
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# 1 << 30 is the default value, but we cannot change it explicitly
|
||||
self.reopen(opts, {'size': (1 << 30)}, "Cannot change the option 'size'")
|
||||
|
||||
# We cannot change 'size' back to its default value either
|
||||
del opts['size']
|
||||
self.reopen(opts, {}, "Option 'size' cannot be reset to its default value")
|
||||
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'root')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
##################
|
||||
###### file ######
|
||||
##################
|
||||
opts = hd_opts(0)
|
||||
opts['file']['locking'] = 'on'
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# 'locking' cannot be changed
|
||||
del opts['file']['locking']
|
||||
self.reopen(opts, {'file.locking': 'on'})
|
||||
self.reopen(opts, {'file.locking': 'off'}, "Cannot change the option 'locking'")
|
||||
self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
|
||||
|
||||
# Trying to reopen the 'file' node directly does not make a difference
|
||||
opts = opts['file']
|
||||
self.reopen(opts, {'locking': 'on'})
|
||||
self.reopen(opts, {'locking': 'off'}, "Cannot change the option 'locking'")
|
||||
self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
|
||||
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
######################
|
||||
###### throttle ######
|
||||
######################
|
||||
opts = { 'qom-type': 'throttle-group', 'id': 'group0',
|
||||
'props': { 'limits': { 'iops-total': 1000 } } }
|
||||
result = self.vm.qmp('object-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
opts = { 'qom-type': 'throttle-group', 'id': 'group1',
|
||||
'props': { 'limits': { 'iops-total': 2000 } } }
|
||||
result = self.vm.qmp('object-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Add a throttle filter with group = group0
|
||||
opts = { 'driver': 'throttle', 'node-name': 'throttle0',
|
||||
'throttle-group': 'group0', 'file': hd_opts(0) }
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# We can reopen it if we keep the same options
|
||||
self.reopen(opts)
|
||||
|
||||
# We can also reopen if 'file' is a reference to the child
|
||||
self.reopen(opts, {'file': 'hd0'})
|
||||
|
||||
# This is illegal
|
||||
self.reopen(opts, {'throttle-group': 'notfound'}, "Throttle group 'notfound' does not exist")
|
||||
|
||||
# But it's possible to change the group to group1
|
||||
self.reopen(opts, {'throttle-group': 'group1'})
|
||||
|
||||
# Now group1 is in use, it cannot be deleted
|
||||
result = self.vm.qmp('object-del', id = 'group1')
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
self.assert_qmp(result, 'error/desc', "object 'group1' is in use, can not be deleted")
|
||||
|
||||
# Default options, this switches the group back to group0
|
||||
self.reopen(opts)
|
||||
|
||||
# So now we cannot delete group0
|
||||
result = self.vm.qmp('object-del', id = 'group0')
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
self.assert_qmp(result, 'error/desc', "object 'group0' is in use, can not be deleted")
|
||||
|
||||
# But group1 is free this time, and it can be deleted
|
||||
result = self.vm.qmp('object-del', id = 'group1')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Let's delete the filter node
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'throttle0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# And we can finally get rid of group0
|
||||
result = self.vm.qmp('object-del', id = 'group0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# If an image has a backing file then the 'backing' option must be
|
||||
# passed on reopen. We don't allow leaving the option out in this
|
||||
# case because it's unclear what the correct semantics would be.
|
||||
def test_missing_backing_options_1(self):
|
||||
# hd2
|
||||
opts = hd_opts(2)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# hd0
|
||||
opts = hd_opts(0)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# hd0 has no backing file: we can omit the 'backing' option
|
||||
self.reopen(opts)
|
||||
|
||||
# hd2 <- hd0
|
||||
self.reopen(opts, {'backing': 'hd2'})
|
||||
|
||||
# hd0 has a backing file: we must set the 'backing' option
|
||||
self.reopen(opts, {}, "backing is missing for 'hd0'")
|
||||
|
||||
# hd2 can't be removed because it's the backing file of hd0
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
|
||||
self.assert_qmp(result, 'error/class', 'GenericError')
|
||||
self.assert_qmp(result, 'error/desc', "Node 'hd2' is busy: node is used as backing hd of 'hd0'")
|
||||
|
||||
# Detach hd2 from hd0.
|
||||
self.reopen(opts, {'backing': None})
|
||||
self.reopen(opts, {}, "backing is missing for 'hd0'")
|
||||
|
||||
# Remove both hd0 and hd2
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# If an image has default backing file (as part of its metadata)
|
||||
# then the 'backing' option must be passed on reopen. We don't
|
||||
# allow leaving the option out in this case because it's unclear
|
||||
# what the correct semantics would be.
|
||||
def test_missing_backing_options_2(self):
|
||||
# hd0 <- hd1
|
||||
# (hd0 is hd1's default backing file)
|
||||
opts = hd_opts(1)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# hd1 has a backing file: we can't omit the 'backing' option
|
||||
self.reopen(opts, {}, "backing is missing for 'hd1'")
|
||||
|
||||
# Let's detach the backing file
|
||||
self.reopen(opts, {'backing': None})
|
||||
|
||||
# No backing file attached to hd1 now, but we still can't omit the 'backing' option
|
||||
self.reopen(opts, {}, "backing is missing for 'hd1'")
|
||||
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Test that making 'backing' a reference to an existing child
|
||||
# keeps its current options
|
||||
def test_backing_reference(self):
|
||||
# hd2 <- hd1 <- hd0
|
||||
opts = hd_opts(0)
|
||||
opts['backing'] = hd_opts(1)
|
||||
opts['backing']['backing'] = hd_opts(2)
|
||||
# Enable 'detect-zeroes' on all three nodes
|
||||
opts['detect-zeroes'] = 'on'
|
||||
opts['backing']['detect-zeroes'] = 'on'
|
||||
opts['backing']['backing']['detect-zeroes'] = 'on'
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Reopen the chain passing the minimum amount of required options.
|
||||
# By making 'backing' a reference to hd1 (instead of a sub-dict)
|
||||
# we tell QEMU to keep its current set of options.
|
||||
opts = {'driver': iotests.imgfmt,
|
||||
'node-name': 'hd0',
|
||||
'file': 'hd0-file',
|
||||
'backing': 'hd1' }
|
||||
self.reopen(opts)
|
||||
|
||||
# This has reset 'detect-zeroes' on hd0, but not on hd1 and hd2.
|
||||
self.assert_qmp(self.get_node('hd0'), 'detect_zeroes', 'off')
|
||||
self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
|
||||
self.assert_qmp(self.get_node('hd2'), 'detect_zeroes', 'on')
|
||||
|
||||
# Test what happens if the graph changes due to other operations
|
||||
# such as block-stream
|
||||
def test_block_stream_1(self):
|
||||
# hd1 <- hd0
|
||||
opts = hd_opts(0)
|
||||
opts['backing'] = hd_opts(1)
|
||||
opts['backing']['backing'] = None
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Stream hd1 into hd0 and wait until it's done
|
||||
result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0', device = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
self.wait_until_completed(drive = 'stream0')
|
||||
|
||||
# Now we have only hd0
|
||||
self.assertEqual(self.get_node('hd1'), None)
|
||||
|
||||
# We have backing.* options but there's no backing file anymore
|
||||
self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
|
||||
|
||||
# If we remove the 'backing' option then we can reopen hd0 just fine
|
||||
del opts['backing']
|
||||
self.reopen(opts)
|
||||
|
||||
# We can also reopen hd0 if we set 'backing' to null
|
||||
self.reopen(opts, {'backing': None})
|
||||
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Another block_stream test
|
||||
def test_block_stream_2(self):
|
||||
# hd2 <- hd1 <- hd0
|
||||
opts = hd_opts(0)
|
||||
opts['backing'] = hd_opts(1)
|
||||
opts['backing']['backing'] = hd_opts(2)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# Stream hd1 into hd0 and wait until it's done
|
||||
result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
|
||||
device = 'hd0', base_node = 'hd2')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
self.wait_until_completed(drive = 'stream0')
|
||||
|
||||
# The chain is hd2 <- hd0 now. hd1 is missing
|
||||
self.assertEqual(self.get_node('hd1'), None)
|
||||
|
||||
# The backing options in the dict were meant for hd1, but we cannot
|
||||
# use them with hd2 because hd1 had a backing file while hd2 does not.
|
||||
self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
|
||||
|
||||
# If we remove hd1's options from the dict then things work fine
|
||||
opts['backing'] = opts['backing']['backing']
|
||||
self.reopen(opts)
|
||||
|
||||
# We can also reopen hd0 if we use a reference to the backing file
|
||||
self.reopen(opts, {'backing': 'hd2'})
|
||||
|
||||
# But we cannot leave the option out
|
||||
del opts['backing']
|
||||
self.reopen(opts, {}, "backing is missing for 'hd0'")
|
||||
|
||||
# Now we can delete hd0 (and hd2)
|
||||
result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
self.assertEqual(self.get_node('hd2'), None)
|
||||
|
||||
# Reopen the chain during a block-stream job (from hd1 to hd0)
|
||||
def test_block_stream_3(self):
|
||||
# hd2 <- hd1 <- hd0
|
||||
opts = hd_opts(0)
|
||||
opts['backing'] = hd_opts(1)
|
||||
opts['backing']['backing'] = hd_opts(2)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# hd2 <- hd0
|
||||
result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
|
||||
device = 'hd0', base_node = 'hd2', speed = 512 * 1024)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# We can't remove hd2 while the stream job is ongoing
|
||||
opts['backing']['backing'] = None
|
||||
self.reopen(opts, {}, "Cannot change 'backing' link from 'hd1' to 'hd2'")
|
||||
|
||||
# We can't remove hd1 while the stream job is ongoing
|
||||
opts['backing'] = None
|
||||
self.reopen(opts, {}, "Cannot change 'backing' link from 'hd0' to 'hd1'")
|
||||
|
||||
self.wait_until_completed(drive = 'stream0')
|
||||
|
||||
# Reopen the chain during a block-stream job (from hd2 to hd1)
|
||||
def test_block_stream_4(self):
|
||||
# hd2 <- hd1 <- hd0
|
||||
opts = hd_opts(0)
|
||||
opts['backing'] = hd_opts(1)
|
||||
opts['backing']['backing'] = hd_opts(2)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# hd1 <- hd0
|
||||
result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
|
||||
device = 'hd1', speed = 512 * 1024)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# We can't reopen with the original options because that would
|
||||
# make hd1 read-only and block-stream requires it to be read-write
|
||||
self.reopen(opts, {}, "Can't set node 'hd1' to r/o with copy-on-read enabled")
|
||||
|
||||
# We can't remove hd2 while the stream job is ongoing
|
||||
opts['backing']['backing'] = None
|
||||
self.reopen(opts, {'backing.read-only': False}, "Cannot change 'backing' link from 'hd1' to 'hd2'")
|
||||
|
||||
# We can detach hd1 from hd0 because it doesn't affect the stream job
|
||||
opts['backing'] = None
|
||||
self.reopen(opts)
|
||||
|
||||
self.wait_until_completed(drive = 'stream0')
|
||||
|
||||
# Reopen the chain during a block-commit job (from hd0 to hd2)
|
||||
def test_block_commit_1(self):
|
||||
# hd2 <- hd1 <- hd0
|
||||
opts = hd_opts(0)
|
||||
opts['backing'] = hd_opts(1)
|
||||
opts['backing']['backing'] = hd_opts(2)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
result = self.vm.qmp('block-commit', conv_keys = True, job_id = 'commit0',
|
||||
device = 'hd0', speed = 1024 * 1024)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# We can't remove hd2 while the commit job is ongoing
|
||||
opts['backing']['backing'] = None
|
||||
self.reopen(opts, {}, "Cannot change 'backing' link from 'hd1' to 'hd2'")
|
||||
|
||||
# We can't remove hd1 while the commit job is ongoing
|
||||
opts['backing'] = None
|
||||
self.reopen(opts, {}, "Cannot change 'backing' link from 'hd0' to 'hd1'")
|
||||
|
||||
event = self.vm.event_wait(name='BLOCK_JOB_READY')
|
||||
self.assert_qmp(event, 'data/device', 'commit0')
|
||||
self.assert_qmp(event, 'data/type', 'commit')
|
||||
self.assert_qmp_absent(event, 'data/error')
|
||||
|
||||
result = self.vm.qmp('block-job-complete', device='commit0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
self.wait_until_completed(drive = 'commit0')
|
||||
|
||||
# Reopen the chain during a block-commit job (from hd1 to hd2)
|
||||
def test_block_commit_2(self):
|
||||
# hd2 <- hd1 <- hd0
|
||||
opts = hd_opts(0)
|
||||
opts['backing'] = hd_opts(1)
|
||||
opts['backing']['backing'] = hd_opts(2)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
result = self.vm.qmp('block-commit', conv_keys = True, job_id = 'commit0',
|
||||
device = 'hd0', top_node = 'hd1', speed = 1024 * 1024)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
# We can't remove hd2 while the commit job is ongoing
|
||||
opts['backing']['backing'] = None
|
||||
self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
|
||||
|
||||
# We can't remove hd1 while the commit job is ongoing
|
||||
opts['backing'] = None
|
||||
self.reopen(opts, {}, "Cannot change backing link if 'hd0' has an implicit backing file")
|
||||
|
||||
# hd2 <- hd0
|
||||
self.wait_until_completed(drive = 'commit0')
|
||||
|
||||
self.assert_qmp(self.get_node('hd0'), 'ro', False)
|
||||
self.assertEqual(self.get_node('hd1'), None)
|
||||
self.assert_qmp(self.get_node('hd2'), 'ro', True)
|
||||
|
||||
# We don't allow setting a backing file that uses a different AioContext
|
||||
def test_iothreads(self):
|
||||
opts = hd_opts(0)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
opts2 = hd_opts(2)
|
||||
result = self.vm.qmp('blockdev-add', conv_keys = False, **opts2)
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
result = self.vm.qmp('object-add', qom_type='iothread', id='iothread0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
result = self.vm.qmp('object-add', qom_type='iothread', id='iothread1')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
result = self.vm.qmp('x-blockdev-set-iothread', node_name='hd0', iothread='iothread0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
self.reopen(opts, {'backing': 'hd2'}, "Cannot use a new backing file with a different AioContext")
|
||||
|
||||
result = self.vm.qmp('x-blockdev-set-iothread', node_name='hd2', iothread='iothread1')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
self.reopen(opts, {'backing': 'hd2'}, "Cannot use a new backing file with a different AioContext")
|
||||
|
||||
result = self.vm.qmp('x-blockdev-set-iothread', node_name='hd2', iothread='iothread0')
|
||||
self.assert_qmp(result, 'return', {})
|
||||
|
||||
self.reopen(opts, {'backing': 'hd2'})
|
||||
|
||||
if __name__ == '__main__':
|
||||
iotests.main(supported_fmts=["qcow2"])
|
||||
5
tests/qemu-iotests/245.out
Normal file
5
tests/qemu-iotests/245.out
Normal file
@ -0,0 +1,5 @@
|
||||
..................
|
||||
----------------------------------------------------------------------
|
||||
Ran 18 tests
|
||||
|
||||
OK
|
||||
@ -243,3 +243,4 @@
|
||||
242 rw auto quick
|
||||
243 rw auto quick
|
||||
244 rw auto quick
|
||||
245 rw auto
|
||||
|
||||
@ -751,7 +751,7 @@ static void *virtio_blk_test_setup(GString *cmd_line, void *arg)
|
||||
char *tmp_path = drive_create();
|
||||
|
||||
g_string_append_printf(cmd_line,
|
||||
" -drive if=none,id=drive0,file=%s,format=raw "
|
||||
" -drive if=none,id=drive0,file=%s,format=raw,auto-read-only=off "
|
||||
"-drive if=none,id=drive1,file=null-co://,format=raw ",
|
||||
tmp_path);
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user