haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Block layer patches:

Browse source 
- 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 2019-03-13 14:44:28 +00:00
parent f39901d59f bf3e50f623
commit 36fe770966
26 changed files with 1929 additions and 160 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

440
block.c
View file

@ -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.

16
block/commit.c
View file

@ -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);
}

254
block/file-posix.c
View file

@ -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,

10
block/gluster.c
View file

@ -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;

8
block/mirror.c
View file

@ -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
View file

@ -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,

25
block/qcow2.c
View file

@ -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,

3
block/raw-format.c
View file

@ -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)

7
block/replication.c
View file

@ -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);
}

21
block/stream.c
View file

@ -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
View file

@ -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
View file

@ -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

6
hw/block/nvme.c
View file

@ -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;
}

13
include/block/block.h
View file

@ -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 {

14
include/block/block_int.h
View file

@ -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;
};

66
qapi/block-core.json
View file

@ -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:
#

4
qemu-io-cmds.c
View file

@ -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) {

7
tests/qemu-iotests/051
View file

@ -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

9
tests/qemu-iotests/051.out
View file

@ -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

9
tests/qemu-iotests/051.pc.out
View file

@ -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

31
tests/qemu-iotests/232
View file

@ -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

32
tests/qemu-iotests/232.out
View file

@ -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
View 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
View file

@ -0,0 +1,5 @@
..................
----------------------------------------------------------------------
Ran 18 tests
OK

1
tests/qemu-iotests/group
View file

@ -243,3 +243,4 @@
242 rw auto quick
243 rw auto quick
244 rw auto quick
245 rw auto

2
tests/virtio-blk-test.c
View file

@ -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);