* [PATCH v3 01/33] block: Add BlockDriver.is_format
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 02/33] block: Rename BdrvChildRole to BdrvChildClass Max Reitz
` (31 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
We want to unify child_format and child_file at some point. One of the
important things that set format drivers apart from other drivers is
that they do not expect other format nodes under them (except in the
backing chain), i.e. we must not probe formats inside of formats. That
means we need something on which to distinguish format drivers from
others, and hence this flag.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
---
block/bochs.c | 1 +
block/cloop.c | 1 +
block/crypto.c | 2 ++
block/dmg.c | 1 +
block/parallels.c | 1 +
block/qcow.c | 1 +
block/qcow2.c | 1 +
block/qed.c | 1 +
block/raw-format.c | 1 +
block/vdi.c | 1 +
block/vhdx.c | 1 +
block/vmdk.c | 1 +
block/vpc.c | 1 +
include/block/block_int.h | 7 +++++++
14 files changed, 21 insertions(+)
diff --git a/block/bochs.c b/block/bochs.c
index 32bb83b268..e7bbeaa1c4 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -301,6 +301,7 @@ static BlockDriver bdrv_bochs = {
.bdrv_refresh_limits = bochs_refresh_limits,
.bdrv_co_preadv = bochs_co_preadv,
.bdrv_close = bochs_close,
+ .is_format = true,
};
static void bdrv_bochs_init(void)
diff --git a/block/cloop.c b/block/cloop.c
index 4de94876d4..f90f1a4b4c 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -297,6 +297,7 @@ static BlockDriver bdrv_cloop = {
.bdrv_refresh_limits = cloop_refresh_limits,
.bdrv_co_preadv = cloop_co_preadv,
.bdrv_close = cloop_close,
+ .is_format = true,
};
static void bdrv_cloop_init(void)
diff --git a/block/crypto.c b/block/crypto.c
index 24823835c1..b81f673a51 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -673,6 +673,8 @@ static BlockDriver bdrv_crypto_luks = {
.bdrv_get_info = block_crypto_get_info_luks,
.bdrv_get_specific_info = block_crypto_get_specific_info_luks,
+ .is_format = true,
+
.strong_runtime_opts = block_crypto_strong_runtime_opts,
};
diff --git a/block/dmg.c b/block/dmg.c
index 4a045f2b3e..ef3c6e771d 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -753,6 +753,7 @@ static BlockDriver bdrv_dmg = {
.bdrv_child_perm = bdrv_format_default_perms,
.bdrv_co_preadv = dmg_co_preadv,
.bdrv_close = dmg_close,
+ .is_format = true,
};
static void bdrv_dmg_init(void)
diff --git a/block/parallels.c b/block/parallels.c
index 7a01997659..30eda982bd 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -910,6 +910,7 @@ static BlockDriver bdrv_parallels = {
.bdrv_co_flush_to_os = parallels_co_flush_to_os,
.bdrv_co_readv = parallels_co_readv,
.bdrv_co_writev = parallels_co_writev,
+ .is_format = true,
.supports_backing = true,
.bdrv_co_create = parallels_co_create,
.bdrv_co_create_opts = parallels_co_create_opts,
diff --git a/block/qcow.c b/block/qcow.c
index fce8989868..0e4f09934c 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -1184,6 +1184,7 @@ static BlockDriver bdrv_qcow = {
.bdrv_co_create = qcow_co_create,
.bdrv_co_create_opts = qcow_co_create_opts,
.bdrv_has_zero_init = bdrv_has_zero_init_1,
+ .is_format = true,
.supports_backing = true,
.bdrv_refresh_limits = qcow_refresh_limits,
diff --git a/block/qcow2.c b/block/qcow2.c
index 3c754f616b..875eb7d5d9 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -5567,6 +5567,7 @@ BlockDriver bdrv_qcow2 = {
.bdrv_save_vmstate = qcow2_save_vmstate,
.bdrv_load_vmstate = qcow2_load_vmstate,
+ .is_format = true,
.supports_backing = true,
.bdrv_change_backing_file = qcow2_change_backing_file,
diff --git a/block/qed.c b/block/qed.c
index d8c4e5fb1e..eb6139acbc 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -1663,6 +1663,7 @@ static BlockDriver bdrv_qed = {
.format_name = "qed",
.instance_size = sizeof(BDRVQEDState),
.create_opts = &qed_create_opts,
+ .is_format = true,
.supports_backing = true,
.bdrv_probe = bdrv_qed_probe,
diff --git a/block/raw-format.c b/block/raw-format.c
index 3a76ec7dd2..2429ff0d23 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -567,6 +567,7 @@ BlockDriver bdrv_raw = {
.bdrv_co_copy_range_to = &raw_co_copy_range_to,
.bdrv_co_truncate = &raw_co_truncate,
.bdrv_getlength = &raw_getlength,
+ .is_format = true,
.has_variable_length = true,
.bdrv_measure = &raw_measure,
.bdrv_get_info = &raw_get_info,
diff --git a/block/vdi.c b/block/vdi.c
index 0142da7233..7e87b205b5 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -1051,6 +1051,7 @@ static BlockDriver bdrv_vdi = {
.bdrv_get_info = vdi_get_info,
+ .is_format = true,
.create_opts = &vdi_create_opts,
.bdrv_co_check = vdi_co_check,
};
diff --git a/block/vhdx.c b/block/vhdx.c
index f02d2611be..d3c1619026 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -2241,6 +2241,7 @@ static BlockDriver bdrv_vhdx = {
.bdrv_co_check = vhdx_co_check,
.bdrv_has_zero_init = vhdx_has_zero_init,
+ .is_format = true,
.create_opts = &vhdx_create_opts,
};
diff --git a/block/vmdk.c b/block/vmdk.c
index 20e909d997..631fcd15ab 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -3058,6 +3058,7 @@ static BlockDriver bdrv_vmdk = {
.bdrv_get_info = vmdk_get_info,
.bdrv_gather_child_options = vmdk_gather_child_options,
+ .is_format = true,
.supports_backing = true,
.create_opts = &vmdk_create_opts,
};
diff --git a/block/vpc.c b/block/vpc.c
index a65550298e..7cf0f87a16 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -1248,6 +1248,7 @@ static BlockDriver bdrv_vpc = {
.bdrv_get_info = vpc_get_info,
+ .is_format = true,
.create_opts = &vpc_create_opts,
.bdrv_has_zero_init = vpc_has_zero_init,
.strong_runtime_opts = vpc_strong_runtime_opts,
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 6f9fd5e20e..8d10c94213 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -94,6 +94,13 @@ struct BlockDriver {
* must implement them and return -ENOTSUP.
*/
bool is_filter;
+ /*
+ * Set to true if the BlockDriver is a format driver. Format nodes
+ * generally do not expect their children to be other format nodes
+ * (except for backing files), and so format probing is disabled
+ * on those children.
+ */
+ bool is_format;
/*
* Return true if @to_replace can be replaced by a BDS with the
* same data as @bs without it affecting @bs's behavior (that is,
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 02/33] block: Rename BdrvChildRole to BdrvChildClass
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
2020-02-18 12:42 ` [PATCH v3 01/33] block: Add BlockDriver.is_format Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits Max Reitz
` (30 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
This structure nearly only contains parent callbacks for child state
changes. It cannot really reflect a child's role, because different
roles may overlap (as we will see when real roles are introduced), and
because parents can have custom callbacks even when the child fulfills a
standard role.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
---
block.c | 142 ++++++++++++++++++------------------
block/backup-top.c | 8 +-
block/blkdebug.c | 4 +-
block/blklogwrites.c | 8 +-
block/block-backend.c | 6 +-
block/commit.c | 2 +-
block/copy-on-read.c | 2 +-
block/io.c | 22 +++---
block/mirror.c | 2 +-
block/quorum.c | 2 +-
block/replication.c | 2 +-
block/vvfat.c | 6 +-
blockjob.c | 2 +-
include/block/block.h | 6 +-
include/block/block_int.h | 22 +++---
tests/test-bdrv-drain.c | 36 ++++-----
tests/test-bdrv-graph-mod.c | 2 +-
17 files changed, 141 insertions(+), 133 deletions(-)
diff --git a/block.c b/block.c
index ca2cfbcb62..a1326e956f 100644
--- a/block.c
+++ b/block.c
@@ -76,7 +76,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
const char *reference,
QDict *options, int flags,
BlockDriverState *parent,
- const BdrvChildRole *child_role,
+ const BdrvChildClass *child_class,
Error **errp);
/* If non-zero, use only whitelisted block drivers */
@@ -1031,7 +1031,7 @@ static void bdrv_inherited_options(int *child_flags, QDict *child_options,
*child_flags = flags;
}
-const BdrvChildRole child_file = {
+const BdrvChildClass child_file = {
.parent_is_bds = true,
.get_parent_desc = bdrv_child_get_parent_desc,
.inherit_options = bdrv_inherited_options,
@@ -1059,7 +1059,7 @@ static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
*child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
}
-const BdrvChildRole child_format = {
+const BdrvChildClass child_format = {
.parent_is_bds = true,
.get_parent_desc = bdrv_child_get_parent_desc,
.inherit_options = bdrv_inherited_fmt_options,
@@ -1183,7 +1183,7 @@ static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
return ret;
}
-const BdrvChildRole child_backing = {
+const BdrvChildClass child_backing = {
.parent_is_bds = true,
.get_parent_desc = bdrv_child_get_parent_desc,
.attach = bdrv_backing_attach,
@@ -1785,13 +1785,13 @@ bool bdrv_is_writable(BlockDriverState *bs)
}
static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
- BdrvChild *c, const BdrvChildRole *role,
+ BdrvChild *c, const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t parent_perm, uint64_t parent_shared,
uint64_t *nperm, uint64_t *nshared)
{
assert(bs->drv && bs->drv->bdrv_child_perm);
- bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
+ bs->drv->bdrv_child_perm(bs, c, child_class, reopen_queue,
parent_perm, parent_shared,
nperm, nshared);
/* TODO Take force_share from reopen_queue */
@@ -1885,7 +1885,7 @@ static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q,
uint64_t cur_perm, cur_shared;
bool child_tighten_restr;
- bdrv_child_perm(bs, c->bs, c, c->role, q,
+ bdrv_child_perm(bs, c->bs, c, c->klass, q,
cumulative_perms, cumulative_shared_perms,
&cur_perm, &cur_shared);
ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared, ignore_children,
@@ -1952,7 +1952,7 @@ static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
/* Update all children */
QLIST_FOREACH(c, &bs->children, next) {
uint64_t cur_perm, cur_shared;
- bdrv_child_perm(bs, c->bs, c, c->role, NULL,
+ bdrv_child_perm(bs, c->bs, c, c->klass, NULL,
cumulative_perms, cumulative_shared_perms,
&cur_perm, &cur_shared);
bdrv_child_set_perm(c, cur_perm, cur_shared);
@@ -1977,8 +1977,8 @@ static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
static char *bdrv_child_user_desc(BdrvChild *c)
{
- if (c->role->get_parent_desc) {
- return c->role->get_parent_desc(c);
+ if (c->klass->get_parent_desc) {
+ return c->klass->get_parent_desc(c);
}
return g_strdup("another user");
@@ -2180,14 +2180,14 @@ int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
uint64_t perms, shared;
bdrv_get_cumulative_perm(bs, &parent_perms, &parent_shared);
- bdrv_child_perm(bs, c->bs, c, c->role, NULL, parent_perms, parent_shared,
+ bdrv_child_perm(bs, c->bs, c, c->klass, NULL, parent_perms, parent_shared,
&perms, &shared);
return bdrv_child_try_set_perm(c, perms, shared, errp);
}
void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
@@ -2197,21 +2197,21 @@ void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
}
void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
- bool backing = (role == &child_backing);
- assert(role == &child_backing || role == &child_file);
+ bool backing = (child_class == &child_backing);
+ assert(child_class == &child_backing || child_class == &child_file);
if (!backing) {
int flags = bdrv_reopen_get_flags(reopen_queue, bs);
/* Apart from the modifications below, the same permissions are
* forwarded and left alone as for filters */
- bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
- &perm, &shared);
+ bdrv_filter_default_perms(bs, c, child_class, reopen_queue,
+ perm, shared, &perm, &shared);
/* Format drivers may touch metadata even if the guest doesn't write */
if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
@@ -2288,7 +2288,7 @@ static void bdrv_replace_child_noperm(BdrvChild *child,
* If the new child node is drained but the old one was not, flush
* all outstanding requests to the old child node.
*/
- while (drain_saldo > 0 && child->role->drained_begin) {
+ while (drain_saldo > 0 && child->klass->drained_begin) {
bdrv_parent_drained_begin_single(child, true);
drain_saldo--;
}
@@ -2297,8 +2297,8 @@ static void bdrv_replace_child_noperm(BdrvChild *child,
/* Detach first so that the recursive drain sections coming from @child
* are already gone and we only end the drain sections that came from
* elsewhere. */
- if (child->role->detach) {
- child->role->detach(child);
+ if (child->klass->detach) {
+ child->klass->detach(child);
}
QLIST_REMOVE(child, next_parent);
}
@@ -2320,8 +2320,8 @@ static void bdrv_replace_child_noperm(BdrvChild *child,
/* Attach only after starting new drained sections, so that recursive
* drain sections coming from @child don't get an extra .drained_begin
* callback. */
- if (child->role->attach) {
- child->role->attach(child);
+ if (child->klass->attach) {
+ child->klass->attach(child);
}
}
@@ -2329,7 +2329,7 @@ static void bdrv_replace_child_noperm(BdrvChild *child,
* If the old child node was drained but the new one is not, allow
* requests to come in only after the new node has been attached.
*/
- while (drain_saldo < 0 && child->role->drained_end) {
+ while (drain_saldo < 0 && child->klass->drained_end) {
bdrv_parent_drained_end_single(child);
drain_saldo++;
}
@@ -2402,7 +2402,7 @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)
*/
BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
const char *child_name,
- const BdrvChildRole *child_role,
+ const BdrvChildClass *child_class,
AioContext *ctx,
uint64_t perm, uint64_t shared_perm,
void *opaque, Error **errp)
@@ -2423,7 +2423,7 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
*child = (BdrvChild) {
.bs = NULL,
.name = g_strdup(child_name),
- .role = child_role,
+ .klass = child_class,
.perm = perm,
.shared_perm = shared_perm,
.opaque = opaque,
@@ -2434,15 +2434,15 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
* try moving the parent into the AioContext of child_bs instead. */
if (bdrv_get_aio_context(child_bs) != ctx) {
ret = bdrv_try_set_aio_context(child_bs, ctx, &local_err);
- if (ret < 0 && child_role->can_set_aio_ctx) {
+ if (ret < 0 && child_class->can_set_aio_ctx) {
GSList *ignore = g_slist_prepend(NULL, child);;
ctx = bdrv_get_aio_context(child_bs);
- if (child_role->can_set_aio_ctx(child, ctx, &ignore, NULL)) {
+ if (child_class->can_set_aio_ctx(child, ctx, &ignore, NULL)) {
error_free(local_err);
ret = 0;
g_slist_free(ignore);
ignore = g_slist_prepend(NULL, child);;
- child_role->set_aio_ctx(child, ctx, &ignore);
+ child_class->set_aio_ctx(child, ctx, &ignore);
}
g_slist_free(ignore);
}
@@ -2474,7 +2474,7 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
BlockDriverState *child_bs,
const char *child_name,
- const BdrvChildRole *child_role,
+ const BdrvChildClass *child_class,
Error **errp)
{
BdrvChild *child;
@@ -2483,10 +2483,10 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
assert(parent_bs->drv);
- bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
+ bdrv_child_perm(parent_bs, child_bs, NULL, child_class, NULL,
perm, shared_perm, &perm, &shared_perm);
- child = bdrv_root_attach_child(child_bs, child_name, child_role,
+ child = bdrv_root_attach_child(child_bs, child_name, child_class,
bdrv_get_aio_context(parent_bs),
perm, shared_perm, parent_bs, errp);
if (child == NULL) {
@@ -2562,8 +2562,8 @@ static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
{
BdrvChild *c;
QLIST_FOREACH(c, &bs->parents, next_parent) {
- if (c->role->change_media) {
- c->role->change_media(c, load);
+ if (c->klass->change_media) {
+ c->klass->change_media(c, load);
}
}
}
@@ -2739,7 +2739,7 @@ free_exit:
static BlockDriverState *
bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
- BlockDriverState *parent, const BdrvChildRole *child_role,
+ BlockDriverState *parent, const BdrvChildClass *child_class,
bool allow_none, Error **errp)
{
BlockDriverState *bs = NULL;
@@ -2747,7 +2747,7 @@ bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
char *bdref_key_dot;
const char *reference;
- assert(child_role != NULL);
+ assert(child_class != NULL);
bdref_key_dot = g_strdup_printf("%s.", bdref_key);
qdict_extract_subqdict(options, &image_options, bdref_key_dot);
@@ -2771,7 +2771,7 @@ bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
}
bs = bdrv_open_inherit(filename, reference, image_options, 0,
- parent, child_role, errp);
+ parent, child_class, errp);
if (!bs) {
goto done;
}
@@ -2798,22 +2798,24 @@ done:
BdrvChild *bdrv_open_child(const char *filename,
QDict *options, const char *bdref_key,
BlockDriverState *parent,
- const BdrvChildRole *child_role,
+ const BdrvChildClass *child_class,
bool allow_none, Error **errp)
{
BlockDriverState *bs;
- bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,
+ bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_class,
allow_none, errp);
if (bs == NULL) {
return NULL;
}
- return bdrv_attach_child(parent, bs, bdref_key, child_role, errp);
+ return bdrv_attach_child(parent, bs, bdref_key, child_class, errp);
}
-/* TODO Future callers may need to specify parent/child_role in order for
- * option inheritance to work. Existing callers use it for the root node. */
+/*
+ * TODO Future callers may need to specify parent/child_class in order for
+ * option inheritance to work. Existing callers use it for the root node.
+ */
BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
{
BlockDriverState *bs = NULL;
@@ -2948,7 +2950,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
const char *reference,
QDict *options, int flags,
BlockDriverState *parent,
- const BdrvChildRole *child_role,
+ const BdrvChildClass *child_class,
Error **errp)
{
int ret;
@@ -2962,8 +2964,8 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
QDict *snapshot_options = NULL;
int snapshot_flags = 0;
- assert(!child_role || !flags);
- assert(!child_role == !parent);
+ assert(!child_class || !flags);
+ assert(!child_class == !parent);
if (reference) {
bool options_non_empty = options ? qdict_size(options) : false;
@@ -2999,10 +3001,10 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
bs->explicit_options = qdict_clone_shallow(options);
- if (child_role) {
+ if (child_class) {
bs->inherits_from = parent;
- child_role->inherit_options(&flags, options,
- parent->open_flags, parent->options);
+ child_class->inherit_options(&flags, options,
+ parent->open_flags, parent->options);
}
ret = bdrv_fill_options(&options, filename, &flags, &local_err);
@@ -3313,7 +3315,7 @@ static bool bdrv_recurse_has_child(BlockDriverState *bs,
static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
BlockDriverState *bs,
QDict *options,
- const BdrvChildRole *role,
+ const BdrvChildClass *klass,
QDict *parent_options,
int parent_flags,
bool keep_old_opts)
@@ -3369,7 +3371,7 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
/* Inherit from parent node */
if (parent_options) {
flags = 0;
- role->inherit_options(&flags, options, parent_flags, parent_options);
+ klass->inherit_options(&flags, options, parent_flags, parent_options);
} else {
flags = bdrv_get_flags(bs);
}
@@ -3460,7 +3462,7 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
}
bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options,
- child->role, options, flags, child_keep_old);
+ child->klass, options, flags, child_keep_old);
}
return bs_queue;
@@ -3631,7 +3633,7 @@ static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
} else {
uint64_t nperm, nshared;
- bdrv_child_perm(parent->state.bs, bs, c, c->role, q,
+ bdrv_child_perm(parent->state.bs, bs, c, c->klass, q,
parent->state.perm, parent->state.shared_perm,
&nperm, &nshared);
@@ -4117,7 +4119,7 @@ static bool should_update_child(BdrvChild *c, BlockDriverState *to)
GHashTable *found;
bool ret;
- if (c->role->stay_at_node) {
+ if (c->klass->stay_at_node) {
return false;
}
@@ -4587,9 +4589,9 @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
}
/* If so, update the backing file path in the image file */
- if (c->role->update_filename) {
- ret = c->role->update_filename(c, base, backing_file_str,
- &local_err);
+ if (c->klass->update_filename) {
+ ret = c->klass->update_filename(c, base, backing_file_str,
+ &local_err);
if (ret < 0) {
bdrv_abort_perm_update(base);
error_report_err(local_err);
@@ -5037,8 +5039,8 @@ const char *bdrv_get_parent_name(const BlockDriverState *bs)
/* If multiple parents have a name, just pick the first one. */
QLIST_FOREACH(c, &bs->parents, next_parent) {
- if (c->role->get_name) {
- name = c->role->get_name(c);
+ if (c->klass->get_name) {
+ name = c->klass->get_name(c);
if (name && *name) {
return name;
}
@@ -5418,8 +5420,8 @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
}
QLIST_FOREACH(parent, &bs->parents, next_parent) {
- if (parent->role->activate) {
- parent->role->activate(parent, &local_err);
+ if (parent->klass->activate) {
+ parent->klass->activate(parent, &local_err);
if (local_err) {
bs->open_flags |= BDRV_O_INACTIVE;
error_propagate(errp, local_err);
@@ -5487,7 +5489,7 @@ static bool bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
BdrvChild *parent;
QLIST_FOREACH(parent, &bs->parents, next_parent) {
- if (parent->role->parent_is_bds) {
+ if (parent->klass->parent_is_bds) {
BlockDriverState *parent_bs = parent->opaque;
if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) {
return true;
@@ -5526,8 +5528,8 @@ static int bdrv_inactivate_recurse(BlockDriverState *bs)
}
QLIST_FOREACH(parent, &bs->parents, next_parent) {
- if (parent->role->inactivate) {
- ret = parent->role->inactivate(parent);
+ if (parent->klass->inactivate) {
+ ret = parent->klass->inactivate(parent);
if (ret < 0) {
return ret;
}
@@ -6027,9 +6029,9 @@ void bdrv_set_aio_context_ignore(BlockDriverState *bs,
if (g_slist_find(*ignore, child)) {
continue;
}
- assert(child->role->set_aio_ctx);
+ assert(child->klass->set_aio_ctx);
*ignore = g_slist_prepend(*ignore, child);
- child->role->set_aio_ctx(child, new_context, ignore);
+ child->klass->set_aio_ctx(child, new_context, ignore);
}
bdrv_detach_aio_context(bs);
@@ -6069,15 +6071,17 @@ static bool bdrv_parent_can_set_aio_context(BdrvChild *c, AioContext *ctx,
}
*ignore = g_slist_prepend(*ignore, c);
- /* A BdrvChildRole that doesn't handle AioContext changes cannot
- * tolerate any AioContext changes */
- if (!c->role->can_set_aio_ctx) {
+ /*
+ * A BdrvChildClass that doesn't handle AioContext changes cannot
+ * tolerate any AioContext changes
+ */
+ if (!c->klass->can_set_aio_ctx) {
char *user = bdrv_child_user_desc(c);
error_setg(errp, "Changing iothreads is not supported by %s", user);
g_free(user);
return false;
}
- if (!c->role->can_set_aio_ctx(c, ctx, ignore, errp)) {
+ if (!c->klass->can_set_aio_ctx(c, ctx, ignore, errp)) {
assert(!errp || *errp);
return false;
}
@@ -6463,7 +6467,7 @@ void bdrv_refresh_filename(BlockDriverState *bs)
drv->bdrv_gather_child_options(bs, opts, backing_overridden);
} else {
QLIST_FOREACH(child, &bs->children, next) {
- if (child->role == &child_backing && !backing_overridden) {
+ if (child->klass == &child_backing && !backing_overridden) {
/* We can skip the backing BDS if it has not been overridden */
continue;
}
diff --git a/block/backup-top.c b/block/backup-top.c
index 1bfb360bd3..2d232828ff 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -121,7 +121,7 @@ static void backup_top_refresh_filename(BlockDriverState *bs)
}
static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
@@ -141,7 +141,7 @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
return;
}
- if (role == &child_file) {
+ if (child_class == &child_file) {
/*
* Target child
*
@@ -152,8 +152,8 @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
*nperm = BLK_PERM_WRITE;
} else {
/* Source child */
- bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
- nperm, nshared);
+ bdrv_filter_default_perms(bs, c, child_class, reopen_queue,
+ perm, shared, nperm, nshared);
if (perm & BLK_PERM_WRITE) {
*nperm = *nperm | BLK_PERM_CONSISTENT_READ;
diff --git a/block/blkdebug.c b/block/blkdebug.c
index af44aa973f..f369d54ee4 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -993,14 +993,14 @@ static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,
}
static void blkdebug_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
BDRVBlkdebugState *s = bs->opaque;
- bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
+ bdrv_filter_default_perms(bs, c, child_class, reopen_queue, perm, shared,
nperm, nshared);
*nperm |= s->take_child_perms;
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index 04d8b33607..f3b3259d8d 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -282,7 +282,7 @@ static int64_t blk_log_writes_getlength(BlockDriverState *bs)
}
static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *ro_q,
uint64_t perm, uint64_t shrd,
uint64_t *nperm, uint64_t *nshrd)
@@ -294,9 +294,11 @@ static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
}
if (!strcmp(c->name, "log")) {
- bdrv_format_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
+ bdrv_format_default_perms(bs, c, child_class, ro_q, perm, shrd, nperm,
+ nshrd);
} else {
- bdrv_filter_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
+ bdrv_filter_default_perms(bs, c, child_class, ro_q, perm, shrd, nperm,
+ nshrd);
}
}
diff --git a/block/block-backend.c b/block/block-backend.c
index 8b8f2a80a0..3d7e96e0d4 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -297,7 +297,7 @@ static void blk_root_detach(BdrvChild *child)
}
}
-static const BdrvChildRole child_root = {
+static const BdrvChildClass child_root = {
.inherit_options = blk_root_inherit_options,
.change_media = blk_root_change_media,
@@ -693,7 +693,7 @@ static BlockBackend *bdrv_first_blk(BlockDriverState *bs)
{
BdrvChild *child;
QLIST_FOREACH(child, &bs->parents, next_parent) {
- if (child->role == &child_root) {
+ if (child->klass == &child_root) {
return child->opaque;
}
}
@@ -717,7 +717,7 @@ bool bdrv_is_root_node(BlockDriverState *bs)
BdrvChild *c;
QLIST_FOREACH(c, &bs->parents, next_parent) {
- if (c->role != &child_root) {
+ if (c->klass != &child_root) {
return false;
}
}
diff --git a/block/commit.c b/block/commit.c
index 8e672799af..a712662633 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -223,7 +223,7 @@ static void bdrv_commit_top_refresh_filename(BlockDriverState *bs)
}
static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/copy-on-read.c b/block/copy-on-read.c
index 242d3ff055..7504ca6ffc 100644
--- a/block/copy-on-read.c
+++ b/block/copy-on-read.c
@@ -51,7 +51,7 @@ static int cor_open(BlockDriverState *bs, QDict *options, int flags,
#define PERM_UNCHANGED (BLK_PERM_ALL & ~PERM_PASSTHROUGH)
static void cor_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/io.c b/block/io.c
index 7e4cb74cf4..b41f2bd227 100644
--- a/block/io.c
+++ b/block/io.c
@@ -50,7 +50,7 @@ static void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore,
BdrvChild *c, *next;
QLIST_FOREACH_SAFE(c, &bs->parents, next_parent, next) {
- if (c == ignore || (ignore_bds_parents && c->role->parent_is_bds)) {
+ if (c == ignore || (ignore_bds_parents && c->klass->parent_is_bds)) {
continue;
}
bdrv_parent_drained_begin_single(c, false);
@@ -62,8 +62,8 @@ static void bdrv_parent_drained_end_single_no_poll(BdrvChild *c,
{
assert(c->parent_quiesce_counter > 0);
c->parent_quiesce_counter--;
- if (c->role->drained_end) {
- c->role->drained_end(c, drained_end_counter);
+ if (c->klass->drained_end) {
+ c->klass->drained_end(c, drained_end_counter);
}
}
@@ -81,7 +81,7 @@ static void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,
BdrvChild *c;
QLIST_FOREACH(c, &bs->parents, next_parent) {
- if (c == ignore || (ignore_bds_parents && c->role->parent_is_bds)) {
+ if (c == ignore || (ignore_bds_parents && c->klass->parent_is_bds)) {
continue;
}
bdrv_parent_drained_end_single_no_poll(c, drained_end_counter);
@@ -90,8 +90,8 @@ static void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,
static bool bdrv_parent_drained_poll_single(BdrvChild *c)
{
- if (c->role->drained_poll) {
- return c->role->drained_poll(c);
+ if (c->klass->drained_poll) {
+ return c->klass->drained_poll(c);
}
return false;
}
@@ -103,7 +103,7 @@ static bool bdrv_parent_drained_poll(BlockDriverState *bs, BdrvChild *ignore,
bool busy = false;
QLIST_FOREACH_SAFE(c, &bs->parents, next_parent, next) {
- if (c == ignore || (ignore_bds_parents && c->role->parent_is_bds)) {
+ if (c == ignore || (ignore_bds_parents && c->klass->parent_is_bds)) {
continue;
}
busy |= bdrv_parent_drained_poll_single(c);
@@ -115,8 +115,8 @@ static bool bdrv_parent_drained_poll(BlockDriverState *bs, BdrvChild *ignore,
void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll)
{
c->parent_quiesce_counter++;
- if (c->role->drained_begin) {
- c->role->drained_begin(c);
+ if (c->klass->drained_begin) {
+ c->klass->drained_begin(c);
}
if (poll) {
BDRV_POLL_WHILE(c->bs, bdrv_parent_drained_poll_single(c));
@@ -3325,8 +3325,8 @@ static void bdrv_parent_cb_resize(BlockDriverState *bs)
{
BdrvChild *c;
QLIST_FOREACH(c, &bs->parents, next_parent) {
- if (c->role->resize) {
- c->role->resize(c);
+ if (c->klass->resize) {
+ c->klass->resize(c);
}
}
}
diff --git a/block/mirror.c b/block/mirror.c
index 447051dbc6..d8506af45a 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -1484,7 +1484,7 @@ static void bdrv_mirror_top_refresh_filename(BlockDriverState *bs)
}
static void bdrv_mirror_top_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/quorum.c b/block/quorum.c
index 6d7a56bd93..a0824c300d 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -1151,7 +1151,7 @@ static char *quorum_dirname(BlockDriverState *bs, Error **errp)
}
static void quorum_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/replication.c b/block/replication.c
index d6681b6c84..e268a6e5c5 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -160,7 +160,7 @@ static void replication_close(BlockDriverState *bs)
}
static void replication_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/vvfat.c b/block/vvfat.c
index ab800c4887..d41bdfc934 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3138,7 +3138,7 @@ static void vvfat_qcow_options(int *child_flags, QDict *child_options,
qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
}
-static const BdrvChildRole child_vvfat_qcow = {
+static const BdrvChildClass child_vvfat_qcow = {
.parent_is_bds = true,
.inherit_options = vvfat_qcow_options,
};
@@ -3212,14 +3212,14 @@ err:
}
static void vvfat_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
BDRVVVFATState *s = bs->opaque;
- assert(c == s->qcow || role == &child_backing);
+ assert(c == s->qcow || child_class == &child_backing);
if (c == s->qcow) {
/* This is a private node, nobody should try to attach to it */
diff --git a/blockjob.c b/blockjob.c
index 5d63b1e89d..79f303822b 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -163,7 +163,7 @@ static void child_job_set_aio_ctx(BdrvChild *c, AioContext *ctx,
job->job.aio_context = ctx;
}
-static const BdrvChildRole child_job = {
+static const BdrvChildClass child_job = {
.get_parent_desc = child_job_get_parent_desc,
.drained_begin = child_job_drained_begin,
.drained_poll = child_job_drained_poll,
diff --git a/include/block/block.h b/include/block/block.h
index cd6b5b95aa..fd89eb6c75 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -13,7 +13,7 @@
/* block.c */
typedef struct BlockDriver BlockDriver;
typedef struct BdrvChild BdrvChild;
-typedef struct BdrvChildRole BdrvChildRole;
+typedef struct BdrvChildClass BdrvChildClass;
typedef struct BlockDriverInfo {
/* in bytes, 0 if irrelevant */
@@ -295,7 +295,7 @@ int bdrv_parse_discard_flags(const char *mode, int *flags);
BdrvChild *bdrv_open_child(const char *filename,
QDict *options, const char *bdref_key,
BlockDriverState* parent,
- const BdrvChildRole *child_role,
+ const BdrvChildClass *child_class,
bool allow_none, Error **errp);
BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp);
void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
@@ -538,7 +538,7 @@ void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child);
BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
BlockDriverState *child_bs,
const char *child_name,
- const BdrvChildRole *child_role,
+ const BdrvChildClass *child_class,
Error **errp);
bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 8d10c94213..5d54debc34 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -556,14 +556,14 @@ struct BlockDriver {
* the parents in @parent_perm and @parent_shared.
*
* If @c is NULL, return the permissions for attaching a new child for the
- * given @role.
+ * given @child_class.
*
* If @reopen_queue is non-NULL, don't return the currently needed
* permissions, but those that will be needed after applying the
* @reopen_queue.
*/
void (*bdrv_child_perm)(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t parent_perm, uint64_t parent_shared,
uint64_t *nperm, uint64_t *nshared);
@@ -665,7 +665,7 @@ typedef struct BdrvAioNotifier {
QLIST_ENTRY(BdrvAioNotifier) list;
} BdrvAioNotifier;
-struct BdrvChildRole {
+struct BdrvChildClass {
/* If true, bdrv_replace_node() doesn't change the node this BdrvChild
* points to. */
bool stay_at_node;
@@ -738,14 +738,14 @@ struct BdrvChildRole {
void (*set_aio_ctx)(BdrvChild *child, AioContext *ctx, GSList **ignore);
};
-extern const BdrvChildRole child_file;
-extern const BdrvChildRole child_format;
-extern const BdrvChildRole child_backing;
+extern const BdrvChildClass child_file;
+extern const BdrvChildClass child_format;
+extern const BdrvChildClass child_backing;
struct BdrvChild {
BlockDriverState *bs;
char *name;
- const BdrvChildRole *role;
+ const BdrvChildClass *klass;
void *opaque;
/**
@@ -772,7 +772,7 @@ struct BdrvChild {
/*
* How many times the parent of this child has been drained
- * (through role->drained_*).
+ * (through klass->drained_*).
* Usually, this is equal to bs->quiesce_counter (potentially
* reduced by bdrv_drain_all_count). It may differ while the
* child is entering or leaving a drained section.
@@ -1226,7 +1226,7 @@ void hmp_drive_add_node(Monitor *mon, const char *optstr);
BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
const char *child_name,
- const BdrvChildRole *child_role,
+ const BdrvChildClass *child_class,
AioContext *ctx,
uint64_t perm, uint64_t shared_perm,
void *opaque, Error **errp);
@@ -1254,7 +1254,7 @@ int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp);
* block filters: Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED and RESIZE to
* all children */
void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared);
@@ -1264,7 +1264,7 @@ void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
* requires WRITE | RESIZE for read-write images, always requires
* CONSISTENT_READ and doesn't share WRITE. */
void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared);
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index fa0e6a648b..9d683a6c11 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -86,18 +86,20 @@ static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
}
static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
- /* bdrv_format_default_perms() accepts only these two, so disguise
- * detach_by_driver_cb_role as one of them. */
- if (role != &child_file && role != &child_backing) {
- role = &child_file;
+ /*
+ * bdrv_format_default_perms() accepts only these two, so disguise
+ * detach_by_driver_cb_parent as one of them.
+ */
+ if (child_class != &child_file && child_class != &child_backing) {
+ child_class = &child_file;
}
- bdrv_format_default_perms(bs, c, role, reopen_queue, perm, shared,
+ bdrv_format_default_perms(bs, c, child_class, reopen_queue, perm, shared,
nperm, nshared);
}
@@ -1332,7 +1334,7 @@ static void detach_by_driver_cb_drained_begin(BdrvChild *child)
child_file.drained_begin(child);
}
-static BdrvChildRole detach_by_driver_cb_role;
+static BdrvChildClass detach_by_driver_cb_class;
/*
* Initial graph:
@@ -1349,7 +1351,7 @@ static BdrvChildRole detach_by_driver_cb_role;
*
* by_parent_cb == false: Test that bdrv_drain_invoke() doesn't poll
*
- * PA's BdrvChildRole has a .drained_begin callback that schedules a BH
+ * PA's BdrvChildClass has a .drained_begin callback that schedules a BH
* that does the same graph change. If bdrv_drain_invoke() calls it, the
* state is messed up, but if it is only polled in the single
* BDRV_POLL_WHILE() at the end of the drain, this should work fine.
@@ -1364,8 +1366,8 @@ static void test_detach_indirect(bool by_parent_cb)
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
if (!by_parent_cb) {
- detach_by_driver_cb_role = child_file;
- detach_by_driver_cb_role.drained_begin =
+ detach_by_driver_cb_class = child_file;
+ detach_by_driver_cb_class.drained_begin =
detach_by_driver_cb_drained_begin;
}
@@ -1399,7 +1401,7 @@ static void test_detach_indirect(bool by_parent_cb)
bdrv_ref(a);
bdrv_attach_child(parent_a, a, "PA-A",
- by_parent_cb ? &child_file : &detach_by_driver_cb_role,
+ by_parent_cb ? &child_file : &detach_by_driver_cb_class,
&error_abort);
g_assert_cmpint(parent_a->refcnt, ==, 1);
@@ -1735,7 +1737,7 @@ static int drop_intermediate_poll_update_filename(BdrvChild *child,
/**
* Test a poll in the midst of bdrv_drop_intermediate().
*
- * bdrv_drop_intermediate() calls BdrvChildRole.update_filename(),
+ * bdrv_drop_intermediate() calls BdrvChildClass.update_filename(),
* which can yield or poll. This may lead to graph changes, unless
* the whole subtree in question is drained.
*
@@ -1772,7 +1774,7 @@ static int drop_intermediate_poll_update_filename(BdrvChild *child,
*
* The solution is for bdrv_drop_intermediate() to drain top's
* subtree. This prevents graph changes from happening just because
- * BdrvChildRole.update_filename() yields or polls. Thus, the block
+ * BdrvChildClass.update_filename() yields or polls. Thus, the block
* job is paused during that drained section and must finish before or
* after.
*
@@ -1780,7 +1782,7 @@ static int drop_intermediate_poll_update_filename(BdrvChild *child,
*/
static void test_drop_intermediate_poll(void)
{
- static BdrvChildRole chain_child_role;
+ static BdrvChildClass chain_child_class;
BlockDriverState *chain[3];
TestSimpleBlockJob *job;
BlockDriverState *job_node;
@@ -1788,8 +1790,8 @@ static void test_drop_intermediate_poll(void)
int i;
int ret;
- chain_child_role = child_backing;
- chain_child_role.update_filename = drop_intermediate_poll_update_filename;
+ chain_child_class = child_backing;
+ chain_child_class.update_filename = drop_intermediate_poll_update_filename;
for (i = 0; i < 3; i++) {
char name[32];
@@ -1810,7 +1812,7 @@ static void test_drop_intermediate_poll(void)
if (i) {
/* Takes the reference to chain[i - 1] */
chain[i]->backing = bdrv_attach_child(chain[i], chain[i - 1],
- "chain", &chain_child_role,
+ "chain", &chain_child_class,
&error_abort);
}
}
diff --git a/tests/test-bdrv-graph-mod.c b/tests/test-bdrv-graph-mod.c
index a007754d9e..fef42cb294 100644
--- a/tests/test-bdrv-graph-mod.c
+++ b/tests/test-bdrv-graph-mod.c
@@ -30,7 +30,7 @@ static BlockDriver bdrv_pass_through = {
};
static void no_perm_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ const BdrvChildClass *child_class,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
2020-02-18 12:42 ` [PATCH v3 01/33] block: Add BlockDriver.is_format Max Reitz
2020-02-18 12:42 ` [PATCH v3 02/33] block: Rename BdrvChildRole to BdrvChildClass Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 13:05 ` Eric Blake
2020-05-05 11:19 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 04/33] block: Add BdrvChildRole to BdrvChild Max Reitz
` (29 subsequent siblings)
32 siblings, 2 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
This mask will supplement BdrvChildClass when it comes to what role (or
combination of roles) a child takes for its parent. It consists of
BdrvChildRoleBits values (which is an enum).
Because empty enums are not allowed, let us just start with it filled.
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
include/block/block.h | 38 ++++++++++++++++++++++++++++++++++++++
1 file changed, 38 insertions(+)
diff --git a/include/block/block.h b/include/block/block.h
index fd89eb6c75..8c23948d08 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -268,6 +268,44 @@ enum {
DEFAULT_PERM_UNCHANGED = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH,
};
+enum BdrvChildRoleBits {
+ /* Child stores data */
+ BDRV_CHILD_DATA = (1 << 0),
+
+ /* Child stores metadata */
+ BDRV_CHILD_METADATA = (1 << 1),
+
+ /*
+ * A child to which the parent forwards all reads and writes. It
+ * must present exactly the same visible data as the parent.
+ * Any node may have at most one filtered child at a time.
+ */
+ BDRV_CHILD_FILTERED = (1 << 2),
+
+ /*
+ * Child from which to read all data that isn’t allocated in the
+ * parent (i.e., the backing child); such data is copied to the
+ * parent through COW (and optionally COR).
+ */
+ BDRV_CHILD_COW = (1 << 3),
+
+ /*
+ * The primary child. For most drivers, this is the child whose
+ * filename applies best to the parent node.
+ * Each parent must give this flag to no more than one child at a
+ * time.
+ */
+ BDRV_CHILD_PRIMARY = (1 << 4),
+
+ /* Useful combination of flags */
+ BDRV_CHILD_IMAGE = BDRV_CHILD_DATA
+ | BDRV_CHILD_METADATA
+ | BDRV_CHILD_PRIMARY,
+};
+
+/* Mask of BdrvChildRoleBits values */
+typedef unsigned int BdrvChildRole;
+
char *bdrv_perm_names(uint64_t perm);
uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits
2020-02-18 12:42 ` [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits Max Reitz
@ 2020-02-18 13:05 ` Eric Blake
2020-05-05 11:19 ` Kevin Wolf
1 sibling, 0 replies; 63+ messages in thread
From: Eric Blake @ 2020-02-18 13:05 UTC (permalink / raw)
To: Max Reitz, qemu-block; +Cc: Kevin Wolf, qemu-devel
On 2/18/20 6:42 AM, Max Reitz wrote:
> This mask will supplement BdrvChildClass when it comes to what role (or
> combination of roles) a child takes for its parent. It consists of
> BdrvChildRoleBits values (which is an enum).
>
> Because empty enums are not allowed, let us just start with it filled.
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> ---
> include/block/block.h | 38 ++++++++++++++++++++++++++++++++++++++
> 1 file changed, 38 insertions(+)
> +
> +/* Mask of BdrvChildRoleBits values */
> +typedef unsigned int BdrvChildRole;
> +
I like how it turned out (both the additional comments earlier on, and
the typedef for documentation purposes).
Reviewed-by: Eric Blake <eblake@redhat.com>
--
Eric Blake, Principal Software Engineer
Red Hat, Inc. +1-919-301-3226
Virtualization: qemu.org | libvirt.org
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits
2020-02-18 12:42 ` [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits Max Reitz
2020-02-18 13:05 ` Eric Blake
@ 2020-05-05 11:19 ` Kevin Wolf
2020-05-05 11:59 ` Max Reitz
1 sibling, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-05 11:19 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> This mask will supplement BdrvChildClass when it comes to what role (or
> combination of roles) a child takes for its parent. It consists of
> BdrvChildRoleBits values (which is an enum).
>
> Because empty enums are not allowed, let us just start with it filled.
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> ---
> include/block/block.h | 38 ++++++++++++++++++++++++++++++++++++++
> 1 file changed, 38 insertions(+)
>
> diff --git a/include/block/block.h b/include/block/block.h
> index fd89eb6c75..8c23948d08 100644
> --- a/include/block/block.h
> +++ b/include/block/block.h
> @@ -268,6 +268,44 @@ enum {
> DEFAULT_PERM_UNCHANGED = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH,
> };
>
> +enum BdrvChildRoleBits {
> + /* Child stores data */
> + BDRV_CHILD_DATA = (1 << 0),
> +
> + /* Child stores metadata */
> + BDRV_CHILD_METADATA = (1 << 1),
> +
> + /*
> + * A child to which the parent forwards all reads and writes. It
Is "_all_ reads and writes" really required? Imagine a caching block
driver, should it not be considered a filter because it may just
complete the requests from its cache rather than asking the child?
> + * must present exactly the same visible data as the parent.
> + * Any node may have at most one filtered child at a time.
> + */
> + BDRV_CHILD_FILTERED = (1 << 2),
> +
> + /*
> + * Child from which to read all data that isn’t allocated in the
> + * parent (i.e., the backing child); such data is copied to the
> + * parent through COW (and optionally COR).
> + */
> + BDRV_CHILD_COW = (1 << 3),
> +
> + /*
> + * The primary child. For most drivers, this is the child whose
> + * filename applies best to the parent node.
> + * Each parent must give this flag to no more than one child at a
> + * time.
> + */
> + BDRV_CHILD_PRIMARY = (1 << 4),
And I assume some drivers like quorum don't set it on any child.
> + /* Useful combination of flags */
> + BDRV_CHILD_IMAGE = BDRV_CHILD_DATA
> + | BDRV_CHILD_METADATA
> + | BDRV_CHILD_PRIMARY,
> +};
> +
> +/* Mask of BdrvChildRoleBits values */
> +typedef unsigned int BdrvChildRole;
> +
> char *bdrv_perm_names(uint64_t perm);
> uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm);
The list intuitively makes sense to me. Let me try to think of some
interesting cases to see whether the documentation is complete or
whether it could be improved.
qcow2 is what everyone has in mind, so it should be obvious:
* Without a data file:
* file: BDRV_CHILD_IMAGE
* backing: BDRV_CHILD_COW
* With a data file:
* file: BDRV_CHILD_PRIMARY | BDRV_CHILD_METADATA
* data-file: BDRV_CHILD_DATA
* backing: BDRV_CHILD_COW
We can use VMDK to make things a bit more interesting:
* file: BDRV_CHILD_PRIMARY | BDRV_CHILD_METADATA
* extents.*: BDRV_CHILD_METADATA | BDRV_CHILD_DATA
* backing: BDRV_CHILD_COW
In other words, we can have multiple data and metadata children. Is this
correct or should extents not be marked as metadata? (Checked the final
code: yes we do have multiple of them in vmdk.) Should this be mentioned
in the documentation?
Do we then also want to allow multiple BDRV_CHILD_COW children? We don't
currently have a driver that needs it, but maybe it would be consistent
with DATA and METADATA then. However, it would contradict the
documentation that it's the "Child from which to read all data".
blkverify:
* x-image: BDRV_CHILD_PRIMARY | BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
* x-raw: BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
Hm, according to the documentation, this doesn't work, FILTERED can be
set only for one node. But the condition ("the parent forwards all reads
and writes") applies to both children. I think the documentation should
mention what needs to be done in such cases. For blkverify, both
children are not equal in intention, so I guess the "real" filtered
child is x-image. But for quorum, you can't make any such distinction. I
assume the recommendation should be not to set FILTERED for any child
then.
Looking at the final code... Hm, your choice looks quite different: You
don't have DATA for x-raw, but you make it the PRIMARY and FILTERED
child. I think PRIMARY/FILTERED is just a bug (e.g. getlength and flush
being forwarded only to x-image show that it's primary). I do wonder
whether I have a different interpretation of DATA than you, though.
Also, the comparison makes me wonder whether FILTERED always implies
PRIMARY? Would there ever be a scenario where a child is FILTERED, but
not PRIMARY?
So I'm not completely sure if I understand the roles correctly, but I
guess my understanding is good enough to continue with the rest of the
series.
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits
2020-05-05 11:19 ` Kevin Wolf
@ 2020-05-05 11:59 ` Max Reitz
2020-05-05 12:54 ` Kevin Wolf
0 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-05-05 11:59 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 7718 bytes --]
On 05.05.20 13:19, Kevin Wolf wrote:
> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>> This mask will supplement BdrvChildClass when it comes to what role (or
>> combination of roles) a child takes for its parent. It consists of
>> BdrvChildRoleBits values (which is an enum).
>>
>> Because empty enums are not allowed, let us just start with it filled.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> ---
>> include/block/block.h | 38 ++++++++++++++++++++++++++++++++++++++
>> 1 file changed, 38 insertions(+)
>>
>> diff --git a/include/block/block.h b/include/block/block.h
>> index fd89eb6c75..8c23948d08 100644
>> --- a/include/block/block.h
>> +++ b/include/block/block.h
>> @@ -268,6 +268,44 @@ enum {
>> DEFAULT_PERM_UNCHANGED = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH,
>> };
>>
>> +enum BdrvChildRoleBits {
>> + /* Child stores data */
>> + BDRV_CHILD_DATA = (1 << 0),
>> +
>> + /* Child stores metadata */
>> + BDRV_CHILD_METADATA = (1 << 1),
>> +
>> + /*
>> + * A child to which the parent forwards all reads and writes. It
>
> Is "_all_ reads and writes" really required? Imagine a caching block
> driver, should it not be considered a filter because it may just
> complete the requests from its cache rather than asking the child?
Hm. The important thing is that parent and child always show exactly
the same data, which is the second part of the definition given here.
So maybe we should flip both sentences, e.g.:
“A child which always presents exactly the same visibile data as the
parent, e.g. by virtue of the parent forwarding all reads and writes.”
?
>> + * must present exactly the same visible data as the parent.
>> + * Any node may have at most one filtered child at a time.
>> + */
>> + BDRV_CHILD_FILTERED = (1 << 2),
>> +
>> + /*
>> + * Child from which to read all data that isn’t allocated in the
>> + * parent (i.e., the backing child); such data is copied to the
>> + * parent through COW (and optionally COR).
>> + */
>> + BDRV_CHILD_COW = (1 << 3),
>> +
>> + /*
>> + * The primary child. For most drivers, this is the child whose
>> + * filename applies best to the parent node.
>> + * Each parent must give this flag to no more than one child at a
>> + * time.
>> + */
>> + BDRV_CHILD_PRIMARY = (1 << 4),
>
> And I assume some drivers like quorum don't set it on any child.
I thought “no more than one” implies that.
>> + /* Useful combination of flags */
>> + BDRV_CHILD_IMAGE = BDRV_CHILD_DATA
>> + | BDRV_CHILD_METADATA
>> + | BDRV_CHILD_PRIMARY,
>> +};
>> +
>> +/* Mask of BdrvChildRoleBits values */
>> +typedef unsigned int BdrvChildRole;
>> +
>> char *bdrv_perm_names(uint64_t perm);
>> uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm);
>
> The list intuitively makes sense to me. Let me try to think of some
> interesting cases to see whether the documentation is complete or
> whether it could be improved.
>
>
> qcow2 is what everyone has in mind, so it should be obvious:
>
> * Without a data file:
> * file: BDRV_CHILD_IMAGE
> * backing: BDRV_CHILD_COW
>
> * With a data file:
> * file: BDRV_CHILD_PRIMARY | BDRV_CHILD_METADATA
> * data-file: BDRV_CHILD_DATA
> * backing: BDRV_CHILD_COW
>
>
> We can use VMDK to make things a bit more interesting:
>
> * file: BDRV_CHILD_PRIMARY | BDRV_CHILD_METADATA
> * extents.*: BDRV_CHILD_METADATA | BDRV_CHILD_DATA
> * backing: BDRV_CHILD_COW
>
> In other words, we can have multiple data and metadata children. Is this
> correct or should extents not be marked as metadata? (Checked the final
> code: yes we do have multiple of them in vmdk.) Should this be mentioned
> in the documentation?
If the extents contain metadata (I thought not, but I think I was just
wrong; sparse extents must contain their respective mapping structures),
then yes, they should all be marked as metadata children.
I’m not sure whether that needs to be mentioned explicitly in the doc,
because “Child stores metadata” seems sufficient to me.
> Do we then also want to allow multiple BDRV_CHILD_COW children? We don't
> currently have a driver that needs it, but maybe it would be consistent
> with DATA and METADATA then. However, it would contradict the
> documentation that it's the "Child from which to read all data".
Yes. I would revisit that problem when the need arises.
It seems to me like this would open a whole can of worms, just like
allowing multiple filtered children does.
> blkverify:
>
> * x-image: BDRV_CHILD_PRIMARY | BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
> * x-raw: BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
>
> Hm, according to the documentation, this doesn't work, FILTERED can be
> set only for one node. But the condition ("the parent forwards all reads
> and writes") applies to both children. I think the documentation should
> mention what needs to be done in such cases.
I don’t know. blkverify is a rare exception by design, because it can
abort when both children don’t match. (I suppose we could theoretically
have a quorum mode where a child gets ejected once a mismatch is
detected, but that isn’t the case now.)
Furthermore, I would argue that blkverify actually expects the formatted
image to sometimes differ from the raw image, if anything, because the
format driver is to be tested. This is the reason why I chose x-raw to
be the filtered child.
So there is no general instruction on what to do in such cases that I
followed here, I specifically chose one child based on what blkverify is
and what it’s supposed to do. Therefore, I can’t really give a general
instruction on “what needs to be done in such cases”.
> For blkverify, both
> children are not equal in intention, so I guess the "real" filtered
> child is x-image. But for quorum, you can't make any such distinction. I
> assume the recommendation should be not to set FILTERED for any child
> then.
Quorum just isn’t a filter driver.
> Looking at the final code... Hm, your choice looks quite different: You
> don't have DATA for x-raw, but you make it the PRIMARY and FILTERED
> child. I think PRIMARY/FILTERED is just a bug (e.g. getlength and flush
> being forwarded only to x-image show that it's primary).
I rather consider getlength() a special case. Ideally, we’d forward
getlength() to both and compare the results; however, image formats
might have different size resolution than raw files, so there could be a
difference, but it’d be irrelevant.
It makes then sense to forward it to the formatted image, because
generally formats have byte resolution for the disk size, whereas for
raw files it depends on caching and the filesystem, I think.
As for flush, yes, why do we forward it only to x-image? Why is “the
raw file not important”?
> I do wonder
> whether I have a different interpretation of DATA than you, though.
I never set DATA for FILTERED, because I consider FILTERED to be
stronger than DATA, so once FILTERED is set, it doesn’t matter whether
DATA is set or not. I suppose that should either be mentioned in the
documentation, or we decide that we should always set DATA regardless.
> Also, the comparison makes me wonder whether FILTERED always implies
> PRIMARY? Would there ever be a scenario where a child is FILTERED, but
> not PRIMARY?
I don’t know. I suppose it does. But what’s the implication?
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits
2020-05-05 11:59 ` Max Reitz
@ 2020-05-05 12:54 ` Kevin Wolf
2020-05-05 13:20 ` Max Reitz
0 siblings, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-05 12:54 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
[-- Attachment #1: Type: text/plain, Size: 10098 bytes --]
Am 05.05.2020 um 13:59 hat Max Reitz geschrieben:
> On 05.05.20 13:19, Kevin Wolf wrote:
> > Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> >> This mask will supplement BdrvChildClass when it comes to what role (or
> >> combination of roles) a child takes for its parent. It consists of
> >> BdrvChildRoleBits values (which is an enum).
> >>
> >> Because empty enums are not allowed, let us just start with it filled.
> >>
> >> Signed-off-by: Max Reitz <mreitz@redhat.com>
> >> ---
> >> include/block/block.h | 38 ++++++++++++++++++++++++++++++++++++++
> >> 1 file changed, 38 insertions(+)
> >>
> >> diff --git a/include/block/block.h b/include/block/block.h
> >> index fd89eb6c75..8c23948d08 100644
> >> --- a/include/block/block.h
> >> +++ b/include/block/block.h
> >> @@ -268,6 +268,44 @@ enum {
> >> DEFAULT_PERM_UNCHANGED = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH,
> >> };
> >>
> >> +enum BdrvChildRoleBits {
> >> + /* Child stores data */
> >> + BDRV_CHILD_DATA = (1 << 0),
> >> +
> >> + /* Child stores metadata */
> >> + BDRV_CHILD_METADATA = (1 << 1),
> >> +
> >> + /*
> >> + * A child to which the parent forwards all reads and writes. It
> >
> > Is "_all_ reads and writes" really required? Imagine a caching block
> > driver, should it not be considered a filter because it may just
> > complete the requests from its cache rather than asking the child?
>
> Hm. The important thing is that parent and child always show exactly
> the same data, which is the second part of the definition given here.
> So maybe we should flip both sentences, e.g.:
>
> “A child which always presents exactly the same visibile data as the
> parent, e.g. by virtue of the parent forwarding all reads and writes.”
>
> ?
Turns it into an example, which is a good way of explaining things that
are commonly, but not universally true. I like it.
> >> + * must present exactly the same visible data as the parent.
> >> + * Any node may have at most one filtered child at a time.
> >> + */
> >> + BDRV_CHILD_FILTERED = (1 << 2),
> >> +
> >> + /*
> >> + * Child from which to read all data that isn’t allocated in the
> >> + * parent (i.e., the backing child); such data is copied to the
> >> + * parent through COW (and optionally COR).
> >> + */
> >> + BDRV_CHILD_COW = (1 << 3),
> >> +
> >> + /*
> >> + * The primary child. For most drivers, this is the child whose
> >> + * filename applies best to the parent node.
> >> + * Each parent must give this flag to no more than one child at a
> >> + * time.
> >> + */
> >> + BDRV_CHILD_PRIMARY = (1 << 4),
> >
> > And I assume some drivers like quorum don't set it on any child.
>
> I thought “no more than one” implies that.
Technically no, though it's probably the first assumption of most
people. It's just a suggestion for clarification, feel free to ignore
it.
> >> + /* Useful combination of flags */
> >> + BDRV_CHILD_IMAGE = BDRV_CHILD_DATA
> >> + | BDRV_CHILD_METADATA
> >> + | BDRV_CHILD_PRIMARY,
> >> +};
> >> +
> >> +/* Mask of BdrvChildRoleBits values */
> >> +typedef unsigned int BdrvChildRole;
> >> +
> >> char *bdrv_perm_names(uint64_t perm);
> >> uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm);
> >
> > The list intuitively makes sense to me. Let me try to think of some
> > interesting cases to see whether the documentation is complete or
> > whether it could be improved.
> >
> >
> > qcow2 is what everyone has in mind, so it should be obvious:
> >
> > * Without a data file:
> > * file: BDRV_CHILD_IMAGE
> > * backing: BDRV_CHILD_COW
> >
> > * With a data file:
> > * file: BDRV_CHILD_PRIMARY | BDRV_CHILD_METADATA
> > * data-file: BDRV_CHILD_DATA
> > * backing: BDRV_CHILD_COW
> >
> >
> > We can use VMDK to make things a bit more interesting:
> >
> > * file: BDRV_CHILD_PRIMARY | BDRV_CHILD_METADATA
> > * extents.*: BDRV_CHILD_METADATA | BDRV_CHILD_DATA
> > * backing: BDRV_CHILD_COW
> >
> > In other words, we can have multiple data and metadata children. Is this
> > correct or should extents not be marked as metadata? (Checked the final
> > code: yes we do have multiple of them in vmdk.) Should this be mentioned
> > in the documentation?
>
> If the extents contain metadata (I thought not, but I think I was just
> wrong; sparse extents must contain their respective mapping structures),
> then yes, they should all be marked as metadata children.
>
> I’m not sure whether that needs to be mentioned explicitly in the doc,
> because “Child stores metadata” seems sufficient to me.
When you're the author, the meaning of everything is clear to you. :-)
In case of doubt, I would be more explicit so that the comment gives a
clear guideline for which role to use in which scenario.
> > Do we then also want to allow multiple BDRV_CHILD_COW children? We don't
> > currently have a driver that needs it, but maybe it would be consistent
> > with DATA and METADATA then. However, it would contradict the
> > documentation that it's the "Child from which to read all data".
>
> Yes. I would revisit that problem when the need arises.
>
> It seems to me like this would open a whole can of worms, just like
> allowing multiple filtered children does.
Okay. Shall we document it explicitly like we do for the filter role?
> > blkverify:
> >
> > * x-image: BDRV_CHILD_PRIMARY | BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
> > * x-raw: BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
> >
> > Hm, according to the documentation, this doesn't work, FILTERED can be
> > set only for one node. But the condition ("the parent forwards all reads
> > and writes") applies to both children. I think the documentation should
> > mention what needs to be done in such cases.
>
> I don’t know. blkverify is a rare exception by design, because it can
> abort when both children don’t match. (I suppose we could theoretically
> have a quorum mode where a child gets ejected once a mismatch is
> detected, but that isn’t the case now.)
Well, yes, this is exceptional. I would ignore that property for
assigning roles because when it comes to play, roles don't matter any
more because the whole process is gone. So...
> Furthermore, I would argue that blkverify actually expects the formatted
> image to sometimes differ from the raw image, if anything, because the
> format driver is to be tested. This is the reason why I chose x-raw to
> be the filtered child.
...I don't think this case is relevant. If blkverify returns something,
both children have the same data.
> So there is no general instruction on what to do in such cases that I
> followed here, I specifically chose one child based on what blkverify is
> and what it’s supposed to do. Therefore, I can’t really give a general
> instruction on “what needs to be done in such cases”.
Maybe the missing part for me is what FILTERED is even used for. I
assume it's for skipping over filters in certain functions in the
generic block layer?
In this case, maybe the right answer is that...
> > For blkverify, both
> > children are not equal in intention, so I guess the "real" filtered
> > child is x-image. But for quorum, you can't make any such distinction. I
> > assume the recommendation should be not to set FILTERED for any child
> > then.
>
> Quorum just isn’t a filter driver.
...blkverify isn't one either because performing an operation on only
one child usually won't be correct.
> > Looking at the final code... Hm, your choice looks quite different: You
> > don't have DATA for x-raw, but you make it the PRIMARY and FILTERED
> > child. I think PRIMARY/FILTERED is just a bug (e.g. getlength and flush
> > being forwarded only to x-image show that it's primary).
>
> I rather consider getlength() a special case. Ideally, we’d forward
> getlength() to both and compare the results; however, image formats
> might have different size resolution than raw files, so there could be a
> difference, but it’d be irrelevant.
>
> It makes then sense to forward it to the formatted image, because
> generally formats have byte resolution for the disk size, whereas for
> raw files it depends on caching and the filesystem, I think.
>
> As for flush, yes, why do we forward it only to x-image? Why is “the
> raw file not important”?
Because it's the copy that is used to check whether the main image is
correct. If things break, you just create a new copy. At least that's
how blkverify was supposed to be used.
In fact, I guess in the typical use cases for blkverify, cache=unsafe is
enough anyway because you would start over from scratch, so... not a
strong argument.
> > I do wonder
> > whether I have a different interpretation of DATA than you, though.
>
> I never set DATA for FILTERED, because I consider FILTERED to be
> stronger than DATA, so once FILTERED is set, it doesn’t matter whether
> DATA is set or not. I suppose that should either be mentioned in the
> documentation, or we decide that we should always set DATA regardless.
Either option should be fine. I guess documenting it is less work.
> > Also, the comparison makes me wonder whether FILTERED always implies
> > PRIMARY? Would there ever be a scenario where a child is FILTERED, but
> > not PRIMARY?
>
> I don’t know. I suppose it does. But what’s the implication?
*shrug* I was just asking to see if I understand things right. We could
document it, but I don't have a good reason why we must do that.
Maybe the more relevant question would be if a FILTERED child must be
the only child to avoid the problems we're discussing for blkverify. But
I think I already answered that question for myself with "no", so
probably not much use asking it.
Kevin
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits
2020-05-05 12:54 ` Kevin Wolf
@ 2020-05-05 13:20 ` Max Reitz
2020-05-05 13:38 ` Kevin Wolf
0 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-05-05 13:20 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 8756 bytes --]
On 05.05.20 14:54, Kevin Wolf wrote:
> Am 05.05.2020 um 13:59 hat Max Reitz geschrieben:
>> On 05.05.20 13:19, Kevin Wolf wrote:
>>> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
[...]
>>>> + /* Useful combination of flags */
>>>> + BDRV_CHILD_IMAGE = BDRV_CHILD_DATA
>>>> + | BDRV_CHILD_METADATA
>>>> + | BDRV_CHILD_PRIMARY,
>>>> +};
>>>> +
>>>> +/* Mask of BdrvChildRoleBits values */
>>>> +typedef unsigned int BdrvChildRole;
>>>> +
>>>> char *bdrv_perm_names(uint64_t perm);
>>>> uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm);
>>>
>>> The list intuitively makes sense to me. Let me try to think of some
>>> interesting cases to see whether the documentation is complete or
>>> whether it could be improved.
>>>
>>>
>>> qcow2 is what everyone has in mind, so it should be obvious:
>>>
>>> * Without a data file:
>>> * file: BDRV_CHILD_IMAGE
>>> * backing: BDRV_CHILD_COW
>>>
>>> * With a data file:
>>> * file: BDRV_CHILD_PRIMARY | BDRV_CHILD_METADATA
>>> * data-file: BDRV_CHILD_DATA
>>> * backing: BDRV_CHILD_COW
>>>
>>>
>>> We can use VMDK to make things a bit more interesting:
>>>
>>> * file: BDRV_CHILD_PRIMARY | BDRV_CHILD_METADATA
>>> * extents.*: BDRV_CHILD_METADATA | BDRV_CHILD_DATA
>>> * backing: BDRV_CHILD_COW
>>>
>>> In other words, we can have multiple data and metadata children. Is this
>>> correct or should extents not be marked as metadata? (Checked the final
>>> code: yes we do have multiple of them in vmdk.) Should this be mentioned
>>> in the documentation?
>>
>> If the extents contain metadata (I thought not, but I think I was just
>> wrong; sparse extents must contain their respective mapping structures),
>> then yes, they should all be marked as metadata children.
>>
>> I’m not sure whether that needs to be mentioned explicitly in the doc,
>> because “Child stores metadata” seems sufficient to me.
>
> When you're the author, the meaning of everything is clear to you. :-)
>
> In case of doubt, I would be more explicit so that the comment gives a
> clear guideline for which role to use in which scenario.
OK, so you mean just noting everywhere explicitly how many children can
get a specific flag, and not just in some cases? That is, make a note
for DATA and METADATA that they can be given to an arbitrary number of
children, and COW only to at most one.
>>> Do we then also want to allow multiple BDRV_CHILD_COW children? We don't
>>> currently have a driver that needs it, but maybe it would be consistent
>>> with DATA and METADATA then. However, it would contradict the
>>> documentation that it's the "Child from which to read all data".
>>
>> Yes. I would revisit that problem when the need arises.
>>
>> It seems to me like this would open a whole can of worms, just like
>> allowing multiple filtered children does.
>
> Okay. Shall we document it explicitly like we do for the filter role?
Yep.
>>> blkverify:
>>>
>>> * x-image: BDRV_CHILD_PRIMARY | BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
>>> * x-raw: BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
>>>
>>> Hm, according to the documentation, this doesn't work, FILTERED can be
>>> set only for one node. But the condition ("the parent forwards all reads
>>> and writes") applies to both children. I think the documentation should
>>> mention what needs to be done in such cases.
>>
>> I don’t know. blkverify is a rare exception by design, because it can
>> abort when both children don’t match. (I suppose we could theoretically
>> have a quorum mode where a child gets ejected once a mismatch is
>> detected, but that isn’t the case now.)
>
> Well, yes, this is exceptional. I would ignore that property for
> assigning roles because when it comes to play, roles don't matter any
> more because the whole process is gone. So...
>
>> Furthermore, I would argue that blkverify actually expects the formatted
>> image to sometimes differ from the raw image, if anything, because the
>> format driver is to be tested. This is the reason why I chose x-raw to
>> be the filtered child.
>
> ...I don't think this case is relevant. If blkverify returns something,
> both children have the same data.
Another argument is that right now, bs->file points to x-raw, and
.is_filter is set. So x-raw is already treated as the filtered child.
>> So there is no general instruction on what to do in such cases that I
>> followed here, I specifically chose one child based on what blkverify is
>> and what it’s supposed to do. Therefore, I can’t really give a general
>> instruction on “what needs to be done in such cases”.
>
> Maybe the missing part for me is what FILTERED is even used for. I
> assume it's for skipping over filters in certain functions in the
> generic block layer?
Yes.
> In this case, maybe the right answer is that...
>
>>> For blkverify, both
>>> children are not equal in intention, so I guess the "real" filtered
>>> child is x-image. But for quorum, you can't make any such distinction. I
>>> assume the recommendation should be not to set FILTERED for any child
>>> then.
>>
>> Quorum just isn’t a filter driver.
>
> ...blkverify isn't one either because performing an operation on only
> one child usually won't be correct.
Good point. It would work if filters are just skipped for functions
that read/query stuff, which I think is the case. I don’t think we ever
skip filters when it comes to modifying data.
In any case, I wouldn’t lose too much sleep over blkverify whatever we
do. It’s a driver used purely for debugging purposes.
>>> Looking at the final code... Hm, your choice looks quite different: You
>>> don't have DATA for x-raw, but you make it the PRIMARY and FILTERED
>>> child. I think PRIMARY/FILTERED is just a bug (e.g. getlength and flush
>>> being forwarded only to x-image show that it's primary).
>>
>> I rather consider getlength() a special case. Ideally, we’d forward
>> getlength() to both and compare the results; however, image formats
>> might have different size resolution than raw files, so there could be a
>> difference, but it’d be irrelevant.
>>
>> It makes then sense to forward it to the formatted image, because
>> generally formats have byte resolution for the disk size, whereas for
>> raw files it depends on caching and the filesystem, I think.
>>
>> As for flush, yes, why do we forward it only to x-image? Why is “the
>> raw file not important”?
>
> Because it's the copy that is used to check whether the main image is
> correct. If things break, you just create a new copy. At least that's
> how blkverify was supposed to be used.
I wonder why blkverify decides that. This should be up to the user, and
if the user wants to keep the verification image around, blkverify
shouldn’t prevent that.
> In fact, I guess in the typical use cases for blkverify, cache=unsafe is
> enough anyway because you would start over from scratch, so... not a
> strong argument.
That too.
>>> I do wonder
>>> whether I have a different interpretation of DATA than you, though.
>>
>> I never set DATA for FILTERED, because I consider FILTERED to be
>> stronger than DATA, so once FILTERED is set, it doesn’t matter whether
>> DATA is set or not. I suppose that should either be mentioned in the
>> documentation, or we decide that we should always set DATA regardless.
>
> Either option should be fine. I guess documenting it is less work.
OK.
>>> Also, the comparison makes me wonder whether FILTERED always implies
>>> PRIMARY? Would there ever be a scenario where a child is FILTERED, but
>>> not PRIMARY?
>>
>> I don’t know. I suppose it does. But what’s the implication?
>
> *shrug* I was just asking to see if I understand things right. We could
> document it, but I don't have a good reason why we must do that.
OK.
> Maybe the more relevant question would be if a FILTERED child must be
> the only child to avoid the problems we're discussing for blkverify. But
> I think I already answered that question for myself with "no", so
> probably not much use asking it.
blkverify is just a bit weird, and I personally don’t mind just treating
it as something “special”, considering it’s just a debugging aid.
Regardless of blkverify, I don’t think FILTERED children must be the
only children, though, because I can well imagine filter drivers having
metadata children on the side, e.g. config data or bitmaps (not just
dirty bitmaps, but also e.g. what to cache for a hypothetical cache driver).
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits
2020-05-05 13:20 ` Max Reitz
@ 2020-05-05 13:38 ` Kevin Wolf
0 siblings, 0 replies; 63+ messages in thread
From: Kevin Wolf @ 2020-05-05 13:38 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
[-- Attachment #1: Type: text/plain, Size: 4625 bytes --]
Am 05.05.2020 um 15:20 hat Max Reitz geschrieben:
> On 05.05.20 14:54, Kevin Wolf wrote:
> > When you're the author, the meaning of everything is clear to you. :-)
> >
> > In case of doubt, I would be more explicit so that the comment gives a
> > clear guideline for which role to use in which scenario.
>
> OK, so you mean just noting everywhere explicitly how many children can
> get a specific flag, and not just in some cases? That is, make a note
> for DATA and METADATA that they can be given to an arbitrary number of
> children, and COW only to at most one.
Sounds good to me.
> >>> blkverify:
> >>>
> >>> * x-image: BDRV_CHILD_PRIMARY | BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
> >>> * x-raw: BDRV_CHILD_DATA | BDRV_CHILD_FILTERED
> >>>
> >>> Hm, according to the documentation, this doesn't work, FILTERED can be
> >>> set only for one node. But the condition ("the parent forwards all reads
> >>> and writes") applies to both children. I think the documentation should
> >>> mention what needs to be done in such cases.
> >>
> >> I don’t know. blkverify is a rare exception by design, because it can
> >> abort when both children don’t match. (I suppose we could theoretically
> >> have a quorum mode where a child gets ejected once a mismatch is
> >> detected, but that isn’t the case now.)
> >
> > Well, yes, this is exceptional. I would ignore that property for
> > assigning roles because when it comes to play, roles don't matter any
> > more because the whole process is gone. So...
> >
> >> Furthermore, I would argue that blkverify actually expects the formatted
> >> image to sometimes differ from the raw image, if anything, because the
> >> format driver is to be tested. This is the reason why I chose x-raw to
> >> be the filtered child.
> >
> > ...I don't think this case is relevant. If blkverify returns something,
> > both children have the same data.
>
> Another argument is that right now, bs->file points to x-raw, and
> .is_filter is set. So x-raw is already treated as the filtered child.
I admit defeat. :-)
> >> So there is no general instruction on what to do in such cases that I
> >> followed here, I specifically chose one child based on what blkverify is
> >> and what it’s supposed to do. Therefore, I can’t really give a general
> >> instruction on “what needs to be done in such cases”.
> >
> > Maybe the missing part for me is what FILTERED is even used for. I
> > assume it's for skipping over filters in certain functions in the
> > generic block layer?
>
> Yes.
>
> > In this case, maybe the right answer is that...
> >
> >>> For blkverify, both
> >>> children are not equal in intention, so I guess the "real" filtered
> >>> child is x-image. But for quorum, you can't make any such distinction. I
> >>> assume the recommendation should be not to set FILTERED for any child
> >>> then.
> >>
> >> Quorum just isn’t a filter driver.
> >
> > ...blkverify isn't one either because performing an operation on only
> > one child usually won't be correct.
>
> Good point. It would work if filters are just skipped for functions
> that read/query stuff, which I think is the case. I don’t think we ever
> skip filters when it comes to modifying data.
>
> In any case, I wouldn’t lose too much sleep over blkverify whatever we
> do. It’s a driver used purely for debugging purposes.
Yeah, I'm not really worried about blkverify per se. It just seems like
an interesting corner case to discuss to make sure that the design of
the role system is right and doesn't miss anything important.
> > Maybe the more relevant question would be if a FILTERED child must be
> > the only child to avoid the problems we're discussing for blkverify. But
> > I think I already answered that question for myself with "no", so
> > probably not much use asking it.
>
> blkverify is just a bit weird, and I personally don’t mind just treating
> it as something “special”, considering it’s just a debugging aid.
>
> Regardless of blkverify, I don’t think FILTERED children must be the
> only children, though, because I can well imagine filter drivers having
> metadata children on the side, e.g. config data or bitmaps (not just
> dirty bitmaps, but also e.g. what to cache for a hypothetical cache driver).
The example of a caching driver that uses a child node for the cached
data (probably on a fast, but small disk) was what made me answer the
question with "no".
But as you write, having a pure metadata child could make sense, too.
Kevin
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 04/33] block: Add BdrvChildRole to BdrvChild
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (2 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 03/33] block: Add BdrvChildRole and BdrvChildRoleBits Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 13:06 ` Eric Blake
2020-02-18 12:42 ` [PATCH v3 05/33] block: Pass BdrvChildRole to bdrv_child_perm() Max Reitz
` (28 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
For now, it is always set to 0. Later patches in this series will
ensure that all callers pass an appropriate combination of flags.
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
block.c | 11 ++++++++---
block/backup-top.c | 3 ++-
block/blkdebug.c | 2 +-
block/blklogwrites.c | 6 +++---
block/blkreplay.c | 2 +-
block/blkverify.c | 4 ++--
block/block-backend.c | 4 ++--
block/bochs.c | 2 +-
block/cloop.c | 2 +-
block/copy-on-read.c | 2 +-
block/crypto.c | 2 +-
block/dmg.c | 2 +-
block/filter-compress.c | 2 +-
block/parallels.c | 2 +-
block/qcow.c | 2 +-
block/qcow2.c | 6 +++---
block/qed.c | 2 +-
block/quorum.c | 4 ++--
block/raw-format.c | 2 +-
block/replication.c | 2 +-
block/throttle.c | 2 +-
block/vdi.c | 2 +-
block/vhdx.c | 2 +-
block/vmdk.c | 4 ++--
block/vpc.c | 2 +-
block/vvfat.c | 2 +-
blockjob.c | 5 +++--
include/block/block.h | 2 ++
include/block/block_int.h | 2 ++
tests/test-bdrv-drain.c | 20 +++++++++++---------
tests/test-bdrv-graph-mod.c | 4 ++--
31 files changed, 62 insertions(+), 49 deletions(-)
diff --git a/block.c b/block.c
index a1326e956f..e8ddf1689e 100644
--- a/block.c
+++ b/block.c
@@ -2403,6 +2403,7 @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)
BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
const char *child_name,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
AioContext *ctx,
uint64_t perm, uint64_t shared_perm,
void *opaque, Error **errp)
@@ -2424,6 +2425,7 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
.bs = NULL,
.name = g_strdup(child_name),
.klass = child_class,
+ .role = child_role,
.perm = perm,
.shared_perm = shared_perm,
.opaque = opaque,
@@ -2475,6 +2477,7 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
BlockDriverState *child_bs,
const char *child_name,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
Error **errp)
{
BdrvChild *child;
@@ -2487,7 +2490,7 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
perm, shared_perm, &perm, &shared_perm);
child = bdrv_root_attach_child(child_bs, child_name, child_class,
- bdrv_get_aio_context(parent_bs),
+ child_role, bdrv_get_aio_context(parent_bs),
perm, shared_perm, parent_bs, errp);
if (child == NULL) {
return NULL;
@@ -2608,7 +2611,7 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
}
bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
- errp);
+ 0, errp);
/* If backing_hd was already part of bs's backing chain, and
* inherits_from pointed recursively to bs then let's update it to
* point directly to bs (else it will become NULL). */
@@ -2799,6 +2802,7 @@ BdrvChild *bdrv_open_child(const char *filename,
QDict *options, const char *bdref_key,
BlockDriverState *parent,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
bool allow_none, Error **errp)
{
BlockDriverState *bs;
@@ -2809,7 +2813,8 @@ BdrvChild *bdrv_open_child(const char *filename,
return NULL;
}
- return bdrv_attach_child(parent, bs, bdref_key, child_class, errp);
+ return bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
+ errp);
}
/*
diff --git a/block/backup-top.c b/block/backup-top.c
index 2d232828ff..b13d459e86 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -209,7 +209,8 @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
source->supported_zero_flags);
bdrv_ref(target);
- state->target = bdrv_attach_child(top, target, "target", &child_file, errp);
+ state->target = bdrv_attach_child(top, target, "target", &child_file, 0,
+ errp);
if (!state->target) {
bdrv_unref(target);
bdrv_unref(top);
diff --git a/block/blkdebug.c b/block/blkdebug.c
index f369d54ee4..c91e78d5c8 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -497,7 +497,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
/* Open the image file */
bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image",
- bs, &child_file, false, &local_err);
+ bs, &child_file, 0, false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index f3b3259d8d..739db6dcf6 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -157,7 +157,7 @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
}
/* Open the file */
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0, false,
&local_err);
if (local_err) {
ret = -EINVAL;
@@ -166,8 +166,8 @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
}
/* Open the log file */
- s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_file, false,
- &local_err);
+ s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_file, 0,
+ false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
diff --git a/block/blkreplay.c b/block/blkreplay.c
index c96ac8f4bc..f97493f45a 100644
--- a/block/blkreplay.c
+++ b/block/blkreplay.c
@@ -28,7 +28,7 @@ static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
/* Open the image file */
bs->file = bdrv_open_child(NULL, options, "image",
- bs, &child_file, false, &local_err);
+ bs, &child_file, 0, false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
diff --git a/block/blkverify.c b/block/blkverify.c
index ba6b1853ae..ba4f6d7b7c 100644
--- a/block/blkverify.c
+++ b/block/blkverify.c
@@ -125,7 +125,7 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags,
/* Open the raw file */
bs->file = bdrv_open_child(qemu_opt_get(opts, "x-raw"), options, "raw",
- bs, &child_file, false, &local_err);
+ bs, &child_file, 0, false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
@@ -134,7 +134,7 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags,
/* Open the test file */
s->test_file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options,
- "test", bs, &child_format, false,
+ "test", bs, &child_format, 0, false,
&local_err);
if (local_err) {
ret = -EINVAL;
diff --git a/block/block-backend.c b/block/block-backend.c
index 3d7e96e0d4..4b79b2abb1 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -400,7 +400,7 @@ BlockBackend *blk_new_open(const char *filename, const char *reference,
return NULL;
}
- blk->root = bdrv_root_attach_child(bs, "root", &child_root, blk->ctx,
+ blk->root = bdrv_root_attach_child(bs, "root", &child_root, 0, blk->ctx,
perm, BLK_PERM_ALL, blk, errp);
if (!blk->root) {
blk_unref(blk);
@@ -811,7 +811,7 @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
{
ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
bdrv_ref(bs);
- blk->root = bdrv_root_attach_child(bs, "root", &child_root, blk->ctx,
+ blk->root = bdrv_root_attach_child(bs, "root", &child_root, 0, blk->ctx,
blk->perm, blk->shared_perm, blk, errp);
if (blk->root == NULL) {
return -EPERM;
diff --git a/block/bochs.c b/block/bochs.c
index e7bbeaa1c4..b013e73063 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -110,7 +110,7 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
return ret;
}
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/cloop.c b/block/cloop.c
index f90f1a4b4c..3ed9fa63cc 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -71,7 +71,7 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
return ret;
}
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/copy-on-read.c b/block/copy-on-read.c
index 7504ca6ffc..a2c4e6dc58 100644
--- a/block/copy-on-read.c
+++ b/block/copy-on-read.c
@@ -28,7 +28,7 @@
static int cor_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0, false,
errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/crypto.c b/block/crypto.c
index b81f673a51..4da74a7737 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -200,7 +200,7 @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
unsigned int cflags = 0;
QDict *cryptoopts = NULL;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/dmg.c b/block/dmg.c
index ef3c6e771d..af8188638c 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -439,7 +439,7 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
return ret;
}
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/filter-compress.c b/block/filter-compress.c
index 82c315b298..4dc5f9fb8c 100644
--- a/block/filter-compress.c
+++ b/block/filter-compress.c
@@ -30,7 +30,7 @@
static int compress_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0, false,
errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/parallels.c b/block/parallels.c
index 30eda982bd..3d5b3b7c63 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -728,7 +728,7 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
Error *local_err = NULL;
char *buf;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/qcow.c b/block/qcow.c
index 0e4f09934c..2bf8e8eb36 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -130,7 +130,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
qdict_extract_subqdict(options, &encryptopts, "encrypt.");
encryptfmt = qdict_get_try_str(encryptopts, "format");
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
ret = -EINVAL;
diff --git a/block/qcow2.c b/block/qcow2.c
index 875eb7d5d9..2ce974df4d 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -1538,7 +1538,7 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
/* Open external data file */
s->data_file = bdrv_open_child(NULL, options, "data-file", bs, &child_file,
- true, &local_err);
+ 0, true, &local_err);
if (local_err) {
error_propagate(errp, local_err);
ret = -EINVAL;
@@ -1548,7 +1548,7 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
if (!s->data_file && s->image_data_file) {
s->data_file = bdrv_open_child(s->image_data_file, options,
- "data-file", bs, &child_file,
+ "data-file", bs, &child_file, 0,
false, errp);
if (!s->data_file) {
ret = -EINVAL;
@@ -1808,7 +1808,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
.ret = -EINPROGRESS
};
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/qed.c b/block/qed.c
index eb6139acbc..d15ba11959 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -547,7 +547,7 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
.ret = -EINPROGRESS
};
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/quorum.c b/block/quorum.c
index a0824c300d..024de76e6f 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -977,7 +977,7 @@ static int quorum_open(BlockDriverState *bs, QDict *options, int flags,
assert(ret < 32);
s->children[i] = bdrv_open_child(NULL, options, indexstr, bs,
- &child_format, false, &local_err);
+ &child_format, 0, false, &local_err);
if (local_err) {
ret = -EINVAL;
goto close_exit;
@@ -1053,7 +1053,7 @@ static void quorum_add_child(BlockDriverState *bs, BlockDriverState *child_bs,
/* We can safely add the child now */
bdrv_ref(child_bs);
- child = bdrv_attach_child(bs, child_bs, indexstr, &child_format, errp);
+ child = bdrv_attach_child(bs, child_bs, indexstr, &child_format, 0, errp);
if (child == NULL) {
s->next_child_index--;
goto out;
diff --git a/block/raw-format.c b/block/raw-format.c
index 2429ff0d23..b600dae209 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -431,7 +431,7 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
BDRVRawState *s = bs->opaque;
int ret;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/replication.c b/block/replication.c
index e268a6e5c5..c05df1bc16 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -90,7 +90,7 @@ static int replication_open(BlockDriverState *bs, QDict *options,
const char *mode;
const char *top_id;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/throttle.c b/block/throttle.c
index 71f4bb0ad1..2dea913be7 100644
--- a/block/throttle.c
+++ b/block/throttle.c
@@ -82,7 +82,7 @@ static int throttle_open(BlockDriverState *bs, QDict *options,
int ret;
bs->file = bdrv_open_child(NULL, options, "file", bs,
- &child_file, false, errp);
+ &child_file, 0, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/vdi.c b/block/vdi.c
index 7e87b205b5..987e2ed592 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -378,7 +378,7 @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
Error *local_err = NULL;
QemuUUID uuid_link, uuid_parent;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/vhdx.c b/block/vhdx.c
index d3c1619026..be23290ac8 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -997,7 +997,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
uint64_t signature;
Error *local_err = NULL;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/vmdk.c b/block/vmdk.c
index 631fcd15ab..84f99d881f 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -1152,7 +1152,7 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
assert(ret < 32);
extent_file = bdrv_open_child(extent_path, options, extent_opt_prefix,
- bs, &child_file, false, &local_err);
+ bs, &child_file, 0, false, &local_err);
g_free(extent_path);
if (local_err) {
error_propagate(errp, local_err);
@@ -1257,7 +1257,7 @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
uint32_t magic;
Error *local_err = NULL;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/vpc.c b/block/vpc.c
index 7cf0f87a16..5378e32d1d 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -228,7 +228,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
int ret;
int64_t bs_size;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/vvfat.c b/block/vvfat.c
index d41bdfc934..022462d9c9 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3185,7 +3185,7 @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
options = qdict_new();
qdict_put_str(options, "write-target.driver", "qcow");
s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
- &child_vvfat_qcow, false, errp);
+ &child_vvfat_qcow, 0, false, errp);
qobject_unref(options);
if (!s->qcow) {
ret = -EINVAL;
diff --git a/blockjob.c b/blockjob.c
index 79f303822b..533ef0af30 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -217,8 +217,9 @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
if (job->job.aio_context != qemu_get_aio_context()) {
aio_context_release(job->job.aio_context);
}
- c = bdrv_root_attach_child(bs, name, &child_job, job->job.aio_context,
- perm, shared_perm, job, errp);
+ c = bdrv_root_attach_child(bs, name, &child_job, 0,
+ job->job.aio_context, perm, shared_perm, job,
+ errp);
if (job->job.aio_context != qemu_get_aio_context()) {
aio_context_acquire(job->job.aio_context);
}
diff --git a/include/block/block.h b/include/block/block.h
index 8c23948d08..01832ec79b 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -334,6 +334,7 @@ BdrvChild *bdrv_open_child(const char *filename,
QDict *options, const char *bdref_key,
BlockDriverState* parent,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
bool allow_none, Error **errp);
BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp);
void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
@@ -577,6 +578,7 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
BlockDriverState *child_bs,
const char *child_name,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
Error **errp);
bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 5d54debc34..0f51ff8f5a 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -746,6 +746,7 @@ struct BdrvChild {
BlockDriverState *bs;
char *name;
const BdrvChildClass *klass;
+ BdrvChildRole role;
void *opaque;
/**
@@ -1227,6 +1228,7 @@ void hmp_drive_add_node(Monitor *mon, const char *optstr);
BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
const char *child_name,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
AioContext *ctx,
uint64_t perm, uint64_t shared_perm,
void *opaque, Error **errp);
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index 9d683a6c11..c03705ea37 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -1202,7 +1202,7 @@ static void do_test_delete_by_drain(bool detach_instead_of_delete,
null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
&error_abort);
- bdrv_attach_child(bs, null_bs, "null-child", &child_file, &error_abort);
+ bdrv_attach_child(bs, null_bs, "null-child", &child_file, 0, &error_abort);
/* This child will be the one to pass to requests through to, and
* it will stall until a drain occurs */
@@ -1211,13 +1211,13 @@ static void do_test_delete_by_drain(bool detach_instead_of_delete,
child_bs->total_sectors = 65536 >> BDRV_SECTOR_BITS;
/* Takes our reference to child_bs */
tts->wait_child = bdrv_attach_child(bs, child_bs, "wait-child", &child_file,
- &error_abort);
+ 0, &error_abort);
/* This child is just there to be deleted
* (for detach_instead_of_delete == true) */
null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
&error_abort);
- bdrv_attach_child(bs, null_bs, "null-child", &child_file, &error_abort);
+ bdrv_attach_child(bs, null_bs, "null-child", &child_file, 0, &error_abort);
blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
blk_insert_bs(blk, bs, &error_abort);
@@ -1314,7 +1314,7 @@ static void detach_indirect_bh(void *opaque)
bdrv_ref(data->c);
data->child_c = bdrv_attach_child(data->parent_b, data->c, "PB-C",
- &child_file, &error_abort);
+ &child_file, 0, &error_abort);
}
static void detach_by_parent_aio_cb(void *opaque, int ret)
@@ -1396,13 +1396,15 @@ static void test_detach_indirect(bool by_parent_cb)
/* Set child relationships */
bdrv_ref(b);
bdrv_ref(a);
- child_b = bdrv_attach_child(parent_b, b, "PB-B", &child_file, &error_abort);
- child_a = bdrv_attach_child(parent_b, a, "PB-A", &child_backing, &error_abort);
+ child_b = bdrv_attach_child(parent_b, b, "PB-B", &child_file, 0,
+ &error_abort);
+ child_a = bdrv_attach_child(parent_b, a, "PB-A", &child_backing, 0,
+ &error_abort);
bdrv_ref(a);
bdrv_attach_child(parent_a, a, "PA-A",
by_parent_cb ? &child_file : &detach_by_driver_cb_class,
- &error_abort);
+ 0, &error_abort);
g_assert_cmpint(parent_a->refcnt, ==, 1);
g_assert_cmpint(parent_b->refcnt, ==, 1);
@@ -1813,7 +1815,7 @@ static void test_drop_intermediate_poll(void)
/* Takes the reference to chain[i - 1] */
chain[i]->backing = bdrv_attach_child(chain[i], chain[i - 1],
"chain", &chain_child_class,
- &error_abort);
+ 0, &error_abort);
}
}
@@ -2031,7 +2033,7 @@ static void do_test_replace_child_mid_drain(int old_drain_count,
bdrv_ref(old_child_bs);
parent_bs->backing = bdrv_attach_child(parent_bs, old_child_bs, "child",
- &child_backing, &error_abort);
+ &child_backing, 0, &error_abort);
for (i = 0; i < old_drain_count; i++) {
bdrv_drained_begin(old_child_bs);
diff --git a/tests/test-bdrv-graph-mod.c b/tests/test-bdrv-graph-mod.c
index fef42cb294..8b8c186c9f 100644
--- a/tests/test-bdrv-graph-mod.c
+++ b/tests/test-bdrv-graph-mod.c
@@ -111,7 +111,7 @@ static void test_update_perm_tree(void)
blk_insert_bs(root, bs, &error_abort);
- bdrv_attach_child(filter, bs, "child", &child_file, &error_abort);
+ bdrv_attach_child(filter, bs, "child", &child_file, 0, &error_abort);
bdrv_append(filter, bs, &local_err);
@@ -177,7 +177,7 @@ static void test_should_update_child(void)
bdrv_set_backing_hd(target, bs, &error_abort);
g_assert(target->backing->bs == bs);
- bdrv_attach_child(filter, target, "target", &child_file, &error_abort);
+ bdrv_attach_child(filter, target, "target", &child_file, 0, &error_abort);
bdrv_append(filter, bs, &error_abort);
g_assert(target->backing->bs == bs);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 04/33] block: Add BdrvChildRole to BdrvChild
2020-02-18 12:42 ` [PATCH v3 04/33] block: Add BdrvChildRole to BdrvChild Max Reitz
@ 2020-02-18 13:06 ` Eric Blake
0 siblings, 0 replies; 63+ messages in thread
From: Eric Blake @ 2020-02-18 13:06 UTC (permalink / raw)
To: Max Reitz, qemu-block; +Cc: Kevin Wolf, qemu-devel
On 2/18/20 6:42 AM, Max Reitz wrote:
> For now, it is always set to 0. Later patches in this series will
> ensure that all callers pass an appropriate combination of flags.
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> ---
> 31 files changed, 62 insertions(+), 49 deletions(-)
Mostly mechanical, and the differences from v2 stem from the type
changes in patch 3.
Reviewed-by: Eric Blake <eblake@redhat.com>
--
Eric Blake, Principal Software Engineer
Red Hat, Inc. +1-919-301-3226
Virtualization: qemu.org | libvirt.org
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 05/33] block: Pass BdrvChildRole to bdrv_child_perm()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (3 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 04/33] block: Add BdrvChildRole to BdrvChild Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 06/33] block: Pass BdrvChildRole to .inherit_options() Max Reitz
` (27 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
For now, all callers pass 0 and no callee evaluates this value. Later
patches will change both.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 22 ++++++++++++----------
block/backup-top.c | 3 ++-
block/blkdebug.c | 5 +++--
block/blklogwrites.c | 9 +++++----
block/commit.c | 1 +
block/copy-on-read.c | 1 +
block/mirror.c | 1 +
block/quorum.c | 1 +
block/replication.c | 1 +
block/vvfat.c | 1 +
include/block/block_int.h | 5 ++++-
tests/test-bdrv-drain.c | 5 +++--
tests/test-bdrv-graph-mod.c | 1 +
13 files changed, 36 insertions(+), 20 deletions(-)
diff --git a/block.c b/block.c
index e8ddf1689e..bfeed6e8d9 100644
--- a/block.c
+++ b/block.c
@@ -1786,12 +1786,12 @@ bool bdrv_is_writable(BlockDriverState *bs)
static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
BdrvChild *c, const BdrvChildClass *child_class,
- BlockReopenQueue *reopen_queue,
+ BdrvChildRole role, BlockReopenQueue *reopen_queue,
uint64_t parent_perm, uint64_t parent_shared,
uint64_t *nperm, uint64_t *nshared)
{
assert(bs->drv && bs->drv->bdrv_child_perm);
- bs->drv->bdrv_child_perm(bs, c, child_class, reopen_queue,
+ bs->drv->bdrv_child_perm(bs, c, child_class, role, reopen_queue,
parent_perm, parent_shared,
nperm, nshared);
/* TODO Take force_share from reopen_queue */
@@ -1885,7 +1885,7 @@ static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q,
uint64_t cur_perm, cur_shared;
bool child_tighten_restr;
- bdrv_child_perm(bs, c->bs, c, c->klass, q,
+ bdrv_child_perm(bs, c->bs, c, c->klass, c->role, q,
cumulative_perms, cumulative_shared_perms,
&cur_perm, &cur_shared);
ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared, ignore_children,
@@ -1952,7 +1952,7 @@ static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
/* Update all children */
QLIST_FOREACH(c, &bs->children, next) {
uint64_t cur_perm, cur_shared;
- bdrv_child_perm(bs, c->bs, c, c->klass, NULL,
+ bdrv_child_perm(bs, c->bs, c, c->klass, c->role, NULL,
cumulative_perms, cumulative_shared_perms,
&cur_perm, &cur_shared);
bdrv_child_set_perm(c, cur_perm, cur_shared);
@@ -2180,14 +2180,15 @@ int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
uint64_t perms, shared;
bdrv_get_cumulative_perm(bs, &parent_perms, &parent_shared);
- bdrv_child_perm(bs, c->bs, c, c->klass, NULL, parent_perms, parent_shared,
- &perms, &shared);
+ bdrv_child_perm(bs, c->bs, c, c->klass, c->role, NULL,
+ parent_perms, parent_shared, &perms, &shared);
return bdrv_child_try_set_perm(c, perms, shared, errp);
}
void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
@@ -2198,6 +2199,7 @@ void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
@@ -2210,7 +2212,7 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
/* Apart from the modifications below, the same permissions are
* forwarded and left alone as for filters */
- bdrv_filter_default_perms(bs, c, child_class, reopen_queue,
+ bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
perm, shared, &perm, &shared);
/* Format drivers may touch metadata even if the guest doesn't write */
@@ -2486,7 +2488,7 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
assert(parent_bs->drv);
- bdrv_child_perm(parent_bs, child_bs, NULL, child_class, NULL,
+ bdrv_child_perm(parent_bs, child_bs, NULL, child_class, child_role, NULL,
perm, shared_perm, &perm, &shared_perm);
child = bdrv_root_attach_child(child_bs, child_name, child_class,
@@ -3524,7 +3526,7 @@ int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
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,
+ NULL, &child_backing, 0, bs_queue,
state->perm, state->shared_perm,
&nperm, &nshared);
ret = bdrv_check_update_perm(state->new_backing_bs, NULL,
@@ -3638,7 +3640,7 @@ static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
} else {
uint64_t nperm, nshared;
- bdrv_child_perm(parent->state.bs, bs, c, c->klass, q,
+ bdrv_child_perm(parent->state.bs, bs, c, c->klass, c->role, q,
parent->state.perm, parent->state.shared_perm,
&nperm, &nshared);
diff --git a/block/backup-top.c b/block/backup-top.c
index b13d459e86..9dd89c2fde 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -122,6 +122,7 @@ static void backup_top_refresh_filename(BlockDriverState *bs)
static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
@@ -152,7 +153,7 @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
*nperm = BLK_PERM_WRITE;
} else {
/* Source child */
- bdrv_filter_default_perms(bs, c, child_class, reopen_queue,
+ bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
perm, shared, nperm, nshared);
if (perm & BLK_PERM_WRITE) {
diff --git a/block/blkdebug.c b/block/blkdebug.c
index c91e78d5c8..8dd8ed6055 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -994,14 +994,15 @@ static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,
static void blkdebug_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
BDRVBlkdebugState *s = bs->opaque;
- bdrv_filter_default_perms(bs, c, child_class, reopen_queue, perm, shared,
- nperm, nshared);
+ bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
*nperm |= s->take_child_perms;
*nshared &= ~s->unshare_child_perms;
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index 739db6dcf6..4faf912ef1 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -283,6 +283,7 @@ static int64_t blk_log_writes_getlength(BlockDriverState *bs)
static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *ro_q,
uint64_t perm, uint64_t shrd,
uint64_t *nperm, uint64_t *nshrd)
@@ -294,11 +295,11 @@ static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
}
if (!strcmp(c->name, "log")) {
- bdrv_format_default_perms(bs, c, child_class, ro_q, perm, shrd, nperm,
- nshrd);
+ bdrv_format_default_perms(bs, c, child_class, role, ro_q, perm, shrd,
+ nperm, nshrd);
} else {
- bdrv_filter_default_perms(bs, c, child_class, ro_q, perm, shrd, nperm,
- nshrd);
+ bdrv_filter_default_perms(bs, c, child_class, role, ro_q, perm, shrd,
+ nperm, nshrd);
}
}
diff --git a/block/commit.c b/block/commit.c
index a712662633..6d094c8cd1 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -224,6 +224,7 @@ static void bdrv_commit_top_refresh_filename(BlockDriverState *bs)
static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/copy-on-read.c b/block/copy-on-read.c
index a2c4e6dc58..a2d92ac394 100644
--- a/block/copy-on-read.c
+++ b/block/copy-on-read.c
@@ -52,6 +52,7 @@ static int cor_open(BlockDriverState *bs, QDict *options, int flags,
static void cor_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/mirror.c b/block/mirror.c
index d8506af45a..25c5e8b622 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -1485,6 +1485,7 @@ static void bdrv_mirror_top_refresh_filename(BlockDriverState *bs)
static void bdrv_mirror_top_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/quorum.c b/block/quorum.c
index 024de76e6f..d37b77a522 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -1152,6 +1152,7 @@ static char *quorum_dirname(BlockDriverState *bs, Error **errp)
static void quorum_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/replication.c b/block/replication.c
index c05df1bc16..9ca5c9368e 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -161,6 +161,7 @@ static void replication_close(BlockDriverState *bs)
static void replication_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/block/vvfat.c b/block/vvfat.c
index 022462d9c9..8e56513604 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3213,6 +3213,7 @@ err:
static void vvfat_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 0f51ff8f5a..826d1bf6bd 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -556,7 +556,7 @@ struct BlockDriver {
* the parents in @parent_perm and @parent_shared.
*
* If @c is NULL, return the permissions for attaching a new child for the
- * given @child_class.
+ * given @child_class and @role.
*
* If @reopen_queue is non-NULL, don't return the currently needed
* permissions, but those that will be needed after applying the
@@ -564,6 +564,7 @@ struct BlockDriver {
*/
void (*bdrv_child_perm)(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t parent_perm, uint64_t parent_shared,
uint64_t *nperm, uint64_t *nshared);
@@ -1257,6 +1258,7 @@ int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp);
* all children */
void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared);
@@ -1267,6 +1269,7 @@ void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
* CONSISTENT_READ and doesn't share WRITE. */
void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared);
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index c03705ea37..b3d7960bd0 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -87,6 +87,7 @@ static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
@@ -99,8 +100,8 @@ static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
child_class = &child_file;
}
- bdrv_format_default_perms(bs, c, child_class, reopen_queue, perm, shared,
- nperm, nshared);
+ bdrv_format_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
}
static int bdrv_test_change_backing_file(BlockDriverState *bs,
diff --git a/tests/test-bdrv-graph-mod.c b/tests/test-bdrv-graph-mod.c
index 8b8c186c9f..3707e2533c 100644
--- a/tests/test-bdrv-graph-mod.c
+++ b/tests/test-bdrv-graph-mod.c
@@ -31,6 +31,7 @@ static BlockDriver bdrv_pass_through = {
static void no_perm_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
+ BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 06/33] block: Pass BdrvChildRole to .inherit_options()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (4 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 05/33] block: Pass BdrvChildRole to bdrv_child_perm() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 07/33] block: Pass parent_is_format " Max Reitz
` (26 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
For now, all callers (effectively) pass 0 and no callee evaluates thie
value. Later patches will change both.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 40 +++++++++++++++++++++++----------------
block/block-backend.c | 3 ++-
block/vvfat.c | 3 ++-
include/block/block_int.h | 3 ++-
4 files changed, 30 insertions(+), 19 deletions(-)
diff --git a/block.c b/block.c
index bfeed6e8d9..9fc865288d 100644
--- a/block.c
+++ b/block.c
@@ -77,6 +77,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
QDict *options, int flags,
BlockDriverState *parent,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
Error **errp);
/* If non-zero, use only whitelisted block drivers */
@@ -1001,7 +1002,8 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
* Returns the options and flags that bs->file should get if a protocol driver
* is expected, based on the given options and flags for the parent BDS
*/
-static void bdrv_inherited_options(int *child_flags, QDict *child_options,
+static void bdrv_inherited_options(BdrvChildRole role,
+ int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
int flags = parent_flags;
@@ -1050,10 +1052,11 @@ const BdrvChildClass child_file = {
* (and not only protocols) is permitted for it, based on the given options and
* flags for the parent BDS
*/
-static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
+static void bdrv_inherited_fmt_options(BdrvChildRole role,
+ int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
- child_file.inherit_options(child_flags, child_options,
+ child_file.inherit_options(role, child_flags, child_options,
parent_flags, parent_options);
*child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
@@ -1134,7 +1137,8 @@ static void bdrv_backing_detach(BdrvChild *c)
* Returns the options and flags that bs->backing should get, based on the
* given options and flags for the parent BDS
*/
-static void bdrv_backing_options(int *child_flags, QDict *child_options,
+static void bdrv_backing_options(BdrvChildRole role,
+ int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
int flags = parent_flags;
@@ -2710,7 +2714,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
}
backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs,
- &child_backing, errp);
+ &child_backing, 0, errp);
if (!backing_hd) {
bs->open_flags |= BDRV_O_NO_BACKING;
error_prepend(errp, "Could not open backing file: ");
@@ -2745,7 +2749,7 @@ free_exit:
static BlockDriverState *
bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
BlockDriverState *parent, const BdrvChildClass *child_class,
- bool allow_none, Error **errp)
+ BdrvChildRole child_role, bool allow_none, Error **errp)
{
BlockDriverState *bs = NULL;
QDict *image_options;
@@ -2776,7 +2780,7 @@ bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
}
bs = bdrv_open_inherit(filename, reference, image_options, 0,
- parent, child_class, errp);
+ parent, child_class, child_role, errp);
if (!bs) {
goto done;
}
@@ -2810,7 +2814,7 @@ BdrvChild *bdrv_open_child(const char *filename,
BlockDriverState *bs;
bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_class,
- allow_none, errp);
+ child_role, allow_none, errp);
if (bs == NULL) {
return NULL;
}
@@ -2859,7 +2863,7 @@ BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
}
- bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, errp);
+ bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, 0, errp);
obj = NULL;
fail:
@@ -2958,6 +2962,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
QDict *options, int flags,
BlockDriverState *parent,
const BdrvChildClass *child_class,
+ BdrvChildRole child_role,
Error **errp)
{
int ret;
@@ -3010,7 +3015,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
if (child_class) {
bs->inherits_from = parent;
- child_class->inherit_options(&flags, options,
+ child_class->inherit_options(child_role, &flags, options,
parent->open_flags, parent->options);
}
@@ -3039,7 +3044,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
flags, options);
/* Let bdrv_backing_options() override "read-only" */
qdict_del(options, BDRV_OPT_READ_ONLY);
- bdrv_backing_options(&flags, options, flags, options);
+ bdrv_backing_options(0, &flags, options, flags, options);
}
bs->open_flags = flags;
@@ -3081,7 +3086,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
BlockDriverState *file_bs;
file_bs = bdrv_open_child_bs(filename, options, "file", bs,
- &child_file, true, &local_err);
+ &child_file, 0, true, &local_err);
if (local_err) {
goto fail;
}
@@ -3226,7 +3231,7 @@ BlockDriverState *bdrv_open(const char *filename, const char *reference,
QDict *options, int flags, Error **errp)
{
return bdrv_open_inherit(filename, reference, options, flags, NULL,
- NULL, errp);
+ NULL, 0, errp);
}
/* Return true if the NULL-terminated @list contains @str */
@@ -3323,6 +3328,7 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
BlockDriverState *bs,
QDict *options,
const BdrvChildClass *klass,
+ BdrvChildRole role,
QDict *parent_options,
int parent_flags,
bool keep_old_opts)
@@ -3378,7 +3384,8 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
/* Inherit from parent node */
if (parent_options) {
flags = 0;
- klass->inherit_options(&flags, options, parent_flags, parent_options);
+ klass->inherit_options(role, &flags, options,
+ parent_flags, parent_options);
} else {
flags = bdrv_get_flags(bs);
}
@@ -3469,7 +3476,8 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
}
bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options,
- child->klass, options, flags, child_keep_old);
+ child->klass, child->role, options, flags,
+ child_keep_old);
}
return bs_queue;
@@ -3479,7 +3487,7 @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
BlockDriverState *bs,
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, 0, NULL, 0,
keep_old_opts);
}
diff --git a/block/block-backend.c b/block/block-backend.c
index 4b79b2abb1..98f3167fa6 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -120,7 +120,8 @@ static QTAILQ_HEAD(, BlockBackend) block_backends =
static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
-static void blk_root_inherit_options(int *child_flags, QDict *child_options,
+static void blk_root_inherit_options(BdrvChildRole role,
+ int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
/* We're not supposed to call this function for root nodes */
diff --git a/block/vvfat.c b/block/vvfat.c
index 8e56513604..7ef2c9cdcc 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3130,7 +3130,8 @@ static BlockDriver vvfat_write_target = {
.bdrv_co_pwritev = write_target_commit,
};
-static void vvfat_qcow_options(int *child_flags, QDict *child_options,
+static void vvfat_qcow_options(BdrvChildRole role,
+ int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "off");
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 826d1bf6bd..fbc1b90088 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -677,7 +677,8 @@ struct BdrvChildClass {
* non-BDS parents. */
bool parent_is_bds;
- void (*inherit_options)(int *child_flags, QDict *child_options,
+ void (*inherit_options)(BdrvChildRole role,
+ int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options);
void (*change_media)(BdrvChild *child, bool load);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 07/33] block: Pass parent_is_format to .inherit_options()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (5 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 06/33] block: Pass BdrvChildRole to .inherit_options() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 08/33] block: Rename bdrv_inherited_options() Max Reitz
` (25 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
We plan to unify the generic .inherit_options() functions. The
resulting common function will need to decide whether to force-enable
format probing, force-disable it, or leave it as-is. To make this
decision, it will need to know whether the parent node is a format node
or not (because we never want format probing if the parent is a format
node already (except for the backing chain)).
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 37 +++++++++++++++++++++++++++----------
block/block-backend.c | 2 +-
block/vvfat.c | 2 +-
include/block/block_int.h | 2 +-
4 files changed, 30 insertions(+), 13 deletions(-)
diff --git a/block.c b/block.c
index 9fc865288d..706fae355e 100644
--- a/block.c
+++ b/block.c
@@ -1002,7 +1002,7 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
* Returns the options and flags that bs->file should get if a protocol driver
* is expected, based on the given options and flags for the parent BDS
*/
-static void bdrv_inherited_options(BdrvChildRole role,
+static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
@@ -1053,10 +1053,12 @@ const BdrvChildClass child_file = {
* flags for the parent BDS
*/
static void bdrv_inherited_fmt_options(BdrvChildRole role,
+ bool parent_is_format,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
- child_file.inherit_options(role, child_flags, child_options,
+ child_file.inherit_options(role, parent_is_format,
+ child_flags, child_options,
parent_flags, parent_options);
*child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
@@ -1137,7 +1139,7 @@ static void bdrv_backing_detach(BdrvChild *c)
* Returns the options and flags that bs->backing should get, based on the
* given options and flags for the parent BDS
*/
-static void bdrv_backing_options(BdrvChildRole role,
+static void bdrv_backing_options(BdrvChildRole role, bool parent_is_format,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
@@ -3014,8 +3016,22 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
bs->explicit_options = qdict_clone_shallow(options);
if (child_class) {
+ bool parent_is_format;
+
+ if (parent->drv) {
+ parent_is_format = parent->drv->is_format;
+ } else {
+ /*
+ * parent->drv is not set yet because this node is opened for
+ * (potential) format probing. That means that @parent is going
+ * to be a format node.
+ */
+ parent_is_format = true;
+ }
+
bs->inherits_from = parent;
- child_class->inherit_options(child_role, &flags, options,
+ child_class->inherit_options(child_role, parent_is_format,
+ &flags, options,
parent->open_flags, parent->options);
}
@@ -3044,7 +3060,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
flags, options);
/* Let bdrv_backing_options() override "read-only" */
qdict_del(options, BDRV_OPT_READ_ONLY);
- bdrv_backing_options(0, &flags, options, flags, options);
+ bdrv_backing_options(0, true, &flags, options, flags, options);
}
bs->open_flags = flags;
@@ -3329,6 +3345,7 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
QDict *options,
const BdrvChildClass *klass,
BdrvChildRole role,
+ bool parent_is_format,
QDict *parent_options,
int parent_flags,
bool keep_old_opts)
@@ -3384,7 +3401,7 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
/* Inherit from parent node */
if (parent_options) {
flags = 0;
- klass->inherit_options(role, &flags, options,
+ klass->inherit_options(role, parent_is_format, &flags, options,
parent_flags, parent_options);
} else {
flags = bdrv_get_flags(bs);
@@ -3476,8 +3493,8 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
}
bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options,
- child->klass, child->role, options, flags,
- child_keep_old);
+ child->klass, child->role, bs->drv->is_format,
+ options, flags, child_keep_old);
}
return bs_queue;
@@ -3487,8 +3504,8 @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
BlockDriverState *bs,
QDict *options, bool keep_old_opts)
{
- return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, 0, NULL, 0,
- keep_old_opts);
+ return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, 0, false,
+ NULL, 0, keep_old_opts);
}
/*
diff --git a/block/block-backend.c b/block/block-backend.c
index 98f3167fa6..9e0078bfb5 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -120,7 +120,7 @@ static QTAILQ_HEAD(, BlockBackend) block_backends =
static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =
QTAILQ_HEAD_INITIALIZER(monitor_block_backends);
-static void blk_root_inherit_options(BdrvChildRole role,
+static void blk_root_inherit_options(BdrvChildRole role, bool parent_is_format,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
diff --git a/block/vvfat.c b/block/vvfat.c
index 7ef2c9cdcc..a945eeb635 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3130,7 +3130,7 @@ static BlockDriver vvfat_write_target = {
.bdrv_co_pwritev = write_target_commit,
};
-static void vvfat_qcow_options(BdrvChildRole role,
+static void vvfat_qcow_options(BdrvChildRole role, bool parent_is_format,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
diff --git a/include/block/block_int.h b/include/block/block_int.h
index fbc1b90088..1f8a818f76 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -677,7 +677,7 @@ struct BdrvChildClass {
* non-BDS parents. */
bool parent_is_bds;
- void (*inherit_options)(BdrvChildRole role,
+ void (*inherit_options)(BdrvChildRole role, bool parent_is_format,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 08/33] block: Rename bdrv_inherited_options()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (6 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 07/33] block: Pass parent_is_format " Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 09/33] block: Add generic bdrv_inherited_options() Max Reitz
` (24 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
The other two .inherit_options implementations specify exactly for what
case they are used in their name, so do it for this one as well.
(The actual intention behind this patch is to follow it up with a
generic bdrv_inherited_options() that works for all three cases.)
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/block.c b/block.c
index 706fae355e..c33f0e9b42 100644
--- a/block.c
+++ b/block.c
@@ -1002,9 +1002,9 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
* Returns the options and flags that bs->file should get if a protocol driver
* is expected, based on the given options and flags for the parent BDS
*/
-static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
- int *child_flags, QDict *child_options,
- int parent_flags, QDict *parent_options)
+static void bdrv_protocol_options(BdrvChildRole role, bool parent_is_format,
+ int *child_flags, QDict *child_options,
+ int parent_flags, QDict *parent_options)
{
int flags = parent_flags;
@@ -1036,7 +1036,7 @@ static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
const BdrvChildClass child_file = {
.parent_is_bds = true,
.get_parent_desc = bdrv_child_get_parent_desc,
- .inherit_options = bdrv_inherited_options,
+ .inherit_options = bdrv_protocol_options,
.drained_begin = bdrv_child_cb_drained_begin,
.drained_poll = bdrv_child_cb_drained_poll,
.drained_end = bdrv_child_cb_drained_end,
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 09/33] block: Add generic bdrv_inherited_options()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (7 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 08/33] block: Rename bdrv_inherited_options() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-05-06 10:37 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 10/33] block: Use bdrv_inherited_options() Max Reitz
` (23 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
After the series this patch belongs to, we want to have a common
BdrvChildClass that encompasses all of child_file, child_format, and
child_backing. Such a single class needs a single .inherit_options()
implementation, and this patch introduces it.
The next patch will show how the existing implementations can fall back
to it just by passing appropriate BdrvChildRole and parent_is_format
values.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 84 insertions(+)
diff --git a/block.c b/block.c
index c33f0e9b42..9179b9b604 100644
--- a/block.c
+++ b/block.c
@@ -998,6 +998,90 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
*child_flags &= ~BDRV_O_NATIVE_AIO;
}
+/*
+ * Returns the options and flags that a generic child of a BDS should
+ * get, based on the given options and flags for the parent BDS.
+ */
+static void __attribute__((unused))
+ bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
+ int *child_flags, QDict *child_options,
+ int parent_flags, QDict *parent_options)
+{
+ int flags = parent_flags;
+
+ /*
+ * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
+ * Generally, the question to answer is: Should this child be
+ * format-probed by default?
+ */
+
+ /*
+ * Pure and non-filtered data children of non-format nodes should
+ * be probed by default (even when the node itself has BDRV_O_PROTOCOL
+ * set). This only affects a very limited set of drivers (namely
+ * quorum and blkverify when this comment was written).
+ * Force-clear BDRV_O_PROTOCOL then.
+ */
+ if (!parent_is_format &&
+ (role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
+ BDRV_CHILD_FILTERED)) ==
+ BDRV_CHILD_DATA)
+ {
+ flags &= ~BDRV_O_PROTOCOL;
+ }
+
+ /*
+ * All children of format nodes (except for COW children) and all
+ * metadata children in general should never be format-probed.
+ * Force-set BDRV_O_PROTOCOL then.
+ */
+ if ((parent_is_format && !(role & BDRV_CHILD_COW)) ||
+ (role & BDRV_CHILD_METADATA))
+ {
+ flags |= BDRV_O_PROTOCOL;
+ }
+
+ /*
+ * If the cache mode isn't explicitly set, inherit direct and no-flush from
+ * the parent.
+ */
+ qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
+ qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
+ qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
+
+ if (role & BDRV_CHILD_COW) {
+ /* backing files are always opened read-only */
+ qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
+ qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
+ } else {
+ /* Inherit the read-only option from the parent if it's not set */
+ qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
+ qdict_copy_default(child_options, parent_options,
+ BDRV_OPT_AUTO_READ_ONLY);
+ }
+
+ if (parent_is_format && !(role & BDRV_CHILD_COW)) {
+ /*
+ * Our format drivers take care to send flushes and respect
+ * unmap policy, so we can default to enable both on lower
+ * layers regardless of the corresponding parent options.
+ */
+ qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
+ }
+
+ /* Clear flags that only apply to the top layer */
+ flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
+
+ if (role & BDRV_CHILD_METADATA) {
+ flags &= ~BDRV_O_NO_IO;
+ }
+ if (role & BDRV_CHILD_COW) {
+ flags &= ~BDRV_O_TEMPORARY;
+ }
+
+ *child_flags = flags;
+}
+
/*
* Returns the options and flags that bs->file should get if a protocol driver
* is expected, based on the given options and flags for the parent BDS
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 09/33] block: Add generic bdrv_inherited_options()
2020-02-18 12:42 ` [PATCH v3 09/33] block: Add generic bdrv_inherited_options() Max Reitz
@ 2020-05-06 10:37 ` Kevin Wolf
2020-05-06 13:11 ` Kevin Wolf
2020-05-07 8:49 ` Max Reitz
0 siblings, 2 replies; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 10:37 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> After the series this patch belongs to, we want to have a common
> BdrvChildClass that encompasses all of child_file, child_format, and
> child_backing. Such a single class needs a single .inherit_options()
> implementation, and this patch introduces it.
>
> The next patch will show how the existing implementations can fall back
> to it just by passing appropriate BdrvChildRole and parent_is_format
> values.
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> Reviewed-by: Eric Blake <eblake@redhat.com>
> ---
> block.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 84 insertions(+)
>
> diff --git a/block.c b/block.c
> index c33f0e9b42..9179b9b604 100644
> --- a/block.c
> +++ b/block.c
> @@ -998,6 +998,90 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
> *child_flags &= ~BDRV_O_NATIVE_AIO;
> }
>
> +/*
> + * Returns the options and flags that a generic child of a BDS should
> + * get, based on the given options and flags for the parent BDS.
> + */
> +static void __attribute__((unused))
> + bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
> + int *child_flags, QDict *child_options,
> + int parent_flags, QDict *parent_options)
> +{
> + int flags = parent_flags;
> +
> + /*
> + * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
> + * Generally, the question to answer is: Should this child be
> + * format-probed by default?
> + */
> +
> + /*
> + * Pure and non-filtered data children of non-format nodes should
> + * be probed by default (even when the node itself has BDRV_O_PROTOCOL
> + * set). This only affects a very limited set of drivers (namely
> + * quorum and blkverify when this comment was written).
> + * Force-clear BDRV_O_PROTOCOL then.
> + */
> + if (!parent_is_format &&
> + (role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
> + BDRV_CHILD_FILTERED)) ==
> + BDRV_CHILD_DATA)
You could avoid the odd indentation (I can't decide whether or not it
should be one space more to align correctly) and probably also make the
expression more readable if you split it into:
(role & BDRV_CHILD_DATA) &&
!(role & (BDRV_CHILD_METADATA | BDRV_CHILD_FILTERED))
> + {
> + flags &= ~BDRV_O_PROTOCOL;
> + }
> +
> + /*
> + * All children of format nodes (except for COW children) and all
> + * metadata children in general should never be format-probed.
> + * Force-set BDRV_O_PROTOCOL then.
> + */
> + if ((parent_is_format && !(role & BDRV_CHILD_COW)) ||
> + (role & BDRV_CHILD_METADATA))
> + {
> + flags |= BDRV_O_PROTOCOL;
> + }
> +
> + /*
> + * If the cache mode isn't explicitly set, inherit direct and no-flush from
> + * the parent.
> + */
> + qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
> + qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
> + qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
> +
> + if (role & BDRV_CHILD_COW) {
> + /* backing files are always opened read-only */
Not "always", just by default.
> + qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
> + qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
> + } else {
> + /* Inherit the read-only option from the parent if it's not set */
> + qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
> + qdict_copy_default(child_options, parent_options,
> + BDRV_OPT_AUTO_READ_ONLY);
> + }
> +
> + if (parent_is_format && !(role & BDRV_CHILD_COW)) {
> + /*
> + * Our format drivers take care to send flushes and respect
> + * unmap policy, so we can default to enable both on lower
> + * layers regardless of the corresponding parent options.
> + */
> + qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
> + }
Why the restriction to format here? Don't we break "unmap" propagation
through filters with this?
It would probably also be a good question why we don't propagate it to
the backing file, but this is preexisting.
> + /* Clear flags that only apply to the top layer */
> + flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
> +
> + if (role & BDRV_CHILD_METADATA) {
> + flags &= ~BDRV_O_NO_IO;
> + }
Hm... This is interesting, but I guess it makes sense. It just never was
a hard rule that a format driver must not access data even internally
with NO_IO, but I think it holds true.
> + if (role & BDRV_CHILD_COW) {
> + flags &= ~BDRV_O_TEMPORARY;
> + }
We could probably have a long discussion about whether this is right in
theory, but in practice BDRV_O_TEMPORARY only exists for snapshot=on,
for which we know that it's always qcow2 with a file and a backing
child. And there is no doubt that we make the right distinction in this
case.
> + *child_flags = flags;
> +}
> +
> /*
> * Returns the options and flags that bs->file should get if a protocol driver
> * is expected, based on the given options and flags for the parent BDS
> --
> 2.24.1
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 09/33] block: Add generic bdrv_inherited_options()
2020-05-06 10:37 ` Kevin Wolf
@ 2020-05-06 13:11 ` Kevin Wolf
2020-05-07 9:18 ` Max Reitz
2020-05-07 8:49 ` Max Reitz
1 sibling, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 13:11 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 06.05.2020 um 12:37 hat Kevin Wolf geschrieben:
> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> > After the series this patch belongs to, we want to have a common
> > BdrvChildClass that encompasses all of child_file, child_format, and
> > child_backing. Such a single class needs a single .inherit_options()
> > implementation, and this patch introduces it.
> >
> > The next patch will show how the existing implementations can fall back
> > to it just by passing appropriate BdrvChildRole and parent_is_format
> > values.
> >
> > Signed-off-by: Max Reitz <mreitz@redhat.com>
> > Reviewed-by: Eric Blake <eblake@redhat.com>
> > ---
> > block.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > 1 file changed, 84 insertions(+)
> >
> > diff --git a/block.c b/block.c
> > index c33f0e9b42..9179b9b604 100644
> > --- a/block.c
> > +++ b/block.c
> > @@ -998,6 +998,90 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
> > *child_flags &= ~BDRV_O_NATIVE_AIO;
> > }
> >
> > +/*
> > + * Returns the options and flags that a generic child of a BDS should
> > + * get, based on the given options and flags for the parent BDS.
> > + */
> > +static void __attribute__((unused))
> > + bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
> > + int *child_flags, QDict *child_options,
> > + int parent_flags, QDict *parent_options)
> > +{
> > + int flags = parent_flags;
> > +
> > + /*
> > + * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
> > + * Generally, the question to answer is: Should this child be
> > + * format-probed by default?
> > + */
Just for clarity: Do you know a good reason to ever leave it (i.e.
inherit it from the parent), except that that's what we have always been
doing for backing files? Though of course, only formats have backing
files, so the flag would never be set in practice in this case.
> > + /*
> > + * Pure and non-filtered data children of non-format nodes should
> > + * be probed by default (even when the node itself has BDRV_O_PROTOCOL
> > + * set). This only affects a very limited set of drivers (namely
> > + * quorum and blkverify when this comment was written).
> > + * Force-clear BDRV_O_PROTOCOL then.
> > + */
> > + if (!parent_is_format &&
> > + (role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
> > + BDRV_CHILD_FILTERED)) ==
> > + BDRV_CHILD_DATA)
>
> You could avoid the odd indentation (I can't decide whether or not it
> should be one space more to align correctly) and probably also make the
> expression more readable if you split it into:
>
> (role & BDRV_CHILD_DATA) &&
> !(role & (BDRV_CHILD_METADATA | BDRV_CHILD_FILTERED))
>
> > + {
> > + flags &= ~BDRV_O_PROTOCOL;
> > + }
> > +
> > + /*
> > + * All children of format nodes (except for COW children) and all
> > + * metadata children in general should never be format-probed.
> > + * Force-set BDRV_O_PROTOCOL then.
> > + */
> > + if ((parent_is_format && !(role & BDRV_CHILD_COW)) ||
> > + (role & BDRV_CHILD_METADATA))
> > + {
> > + flags |= BDRV_O_PROTOCOL;
> > + }
> > +
> > + /*
> > + * If the cache mode isn't explicitly set, inherit direct and no-flush from
> > + * the parent.
> > + */
> > + qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
> > + qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
> > + qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
> > +
> > + if (role & BDRV_CHILD_COW) {
> > + /* backing files are always opened read-only */
>
> Not "always", just by default.
>
> > + qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
> > + qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
> > + } else {
> > + /* Inherit the read-only option from the parent if it's not set */
> > + qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
> > + qdict_copy_default(child_options, parent_options,
> > + BDRV_OPT_AUTO_READ_ONLY);
> > + }
> > +
> > + if (parent_is_format && !(role & BDRV_CHILD_COW)) {
> > + /*
> > + * Our format drivers take care to send flushes and respect
> > + * unmap policy, so we can default to enable both on lower
> > + * layers regardless of the corresponding parent options.
> > + */
> > + qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
> > + }
>
> Why the restriction to format here? Don't we break "unmap" propagation
> through filters with this?
>
> It would probably also be a good question why we don't propagate it to
> the backing file, but this is preexisting.
Some patches later, I think the fix is an else branch that copies the
flag from parent_options.
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 09/33] block: Add generic bdrv_inherited_options()
2020-05-06 13:11 ` Kevin Wolf
@ 2020-05-07 9:18 ` Max Reitz
0 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-05-07 9:18 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 3039 bytes --]
On 06.05.20 15:11, Kevin Wolf wrote:
> Am 06.05.2020 um 12:37 hat Kevin Wolf geschrieben:
>> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>>> After the series this patch belongs to, we want to have a common
>>> BdrvChildClass that encompasses all of child_file, child_format, and
>>> child_backing. Such a single class needs a single .inherit_options()
>>> implementation, and this patch introduces it.
>>>
>>> The next patch will show how the existing implementations can fall back
>>> to it just by passing appropriate BdrvChildRole and parent_is_format
>>> values.
>>>
>>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>>> Reviewed-by: Eric Blake <eblake@redhat.com>
>>> ---
>>> block.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>>> 1 file changed, 84 insertions(+)
>>>
>>> diff --git a/block.c b/block.c
>>> index c33f0e9b42..9179b9b604 100644
>>> --- a/block.c
>>> +++ b/block.c
>>> @@ -998,6 +998,90 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
>>> *child_flags &= ~BDRV_O_NATIVE_AIO;
>>> }
>>>
>>> +/*
>>> + * Returns the options and flags that a generic child of a BDS should
>>> + * get, based on the given options and flags for the parent BDS.
>>> + */
>>> +static void __attribute__((unused))
>>> + bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
>>> + int *child_flags, QDict *child_options,
>>> + int parent_flags, QDict *parent_options)
>>> +{
>>> + int flags = parent_flags;
>>> +
>>> + /*
>>> + * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
>>> + * Generally, the question to answer is: Should this child be
>>> + * format-probed by default?
>>> + */
>
> Just for clarity: Do you know a good reason to ever leave it (i.e.
> inherit it from the parent), except that that's what we have always been
> doing for backing files? Though of course, only formats have backing
> files, so the flag would never be set in practice in this case.
It seems correct for filters.
[...]
>>> + if (parent_is_format && !(role & BDRV_CHILD_COW)) {
>>> + /*
>>> + * Our format drivers take care to send flushes and respect
>>> + * unmap policy, so we can default to enable both on lower
>>> + * layers regardless of the corresponding parent options.
>>> + */
>>> + qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
>>> + }
>>
>> Why the restriction to format here? Don't we break "unmap" propagation
>> through filters with this?
>>
>> It would probably also be a good question why we don't propagate it to
>> the backing file, but this is preexisting.
>
> Some patches later, I think the fix is an else branch that copies the
> flag from parent_options.
I thought about the same thing, but is that really necessary if
bdrv_co_pdiscard() will already suppress discards on the parent if unmap
is false?
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 09/33] block: Add generic bdrv_inherited_options()
2020-05-06 10:37 ` Kevin Wolf
2020-05-06 13:11 ` Kevin Wolf
@ 2020-05-07 8:49 ` Max Reitz
2020-05-07 11:19 ` Kevin Wolf
1 sibling, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-05-07 8:49 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 5969 bytes --]
On 06.05.20 12:37, Kevin Wolf wrote:
> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>> After the series this patch belongs to, we want to have a common
>> BdrvChildClass that encompasses all of child_file, child_format, and
>> child_backing. Such a single class needs a single .inherit_options()
>> implementation, and this patch introduces it.
>>
>> The next patch will show how the existing implementations can fall back
>> to it just by passing appropriate BdrvChildRole and parent_is_format
>> values.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> Reviewed-by: Eric Blake <eblake@redhat.com>
>> ---
>> block.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>> 1 file changed, 84 insertions(+)
>>
>> diff --git a/block.c b/block.c
>> index c33f0e9b42..9179b9b604 100644
>> --- a/block.c
>> +++ b/block.c
>> @@ -998,6 +998,90 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
>> *child_flags &= ~BDRV_O_NATIVE_AIO;
>> }
>>
>> +/*
>> + * Returns the options and flags that a generic child of a BDS should
>> + * get, based on the given options and flags for the parent BDS.
>> + */
>> +static void __attribute__((unused))
>> + bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
>> + int *child_flags, QDict *child_options,
>> + int parent_flags, QDict *parent_options)
>> +{
>> + int flags = parent_flags;
>> +
>> + /*
>> + * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
>> + * Generally, the question to answer is: Should this child be
>> + * format-probed by default?
>> + */
>> +
>> + /*
>> + * Pure and non-filtered data children of non-format nodes should
>> + * be probed by default (even when the node itself has BDRV_O_PROTOCOL
>> + * set). This only affects a very limited set of drivers (namely
>> + * quorum and blkverify when this comment was written).
>> + * Force-clear BDRV_O_PROTOCOL then.
>> + */
>> + if (!parent_is_format &&
>> + (role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
>> + BDRV_CHILD_FILTERED)) ==
>> + BDRV_CHILD_DATA)
>
> You could avoid the odd indentation (I can't decide whether or not it
> should be one space more to align correctly) and probably also make the
> expression more readable if you split it into:
>
> (role & BDRV_CHILD_DATA) &&
> !(role & (BDRV_CHILD_METADATA | BDRV_CHILD_FILTERED))
Yes, looks good.
>> + {
>> + flags &= ~BDRV_O_PROTOCOL;
>> + }
>> +
>> + /*
>> + * All children of format nodes (except for COW children) and all
>> + * metadata children in general should never be format-probed.
>> + * Force-set BDRV_O_PROTOCOL then.
>> + */
>> + if ((parent_is_format && !(role & BDRV_CHILD_COW)) ||
>> + (role & BDRV_CHILD_METADATA))
>> + {
>> + flags |= BDRV_O_PROTOCOL;
>> + }
>> +
>> + /*
>> + * If the cache mode isn't explicitly set, inherit direct and no-flush from
>> + * the parent.
>> + */
>> + qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
>> + qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
>> + qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
>> +
>> + if (role & BDRV_CHILD_COW) {
>> + /* backing files are always opened read-only */
>
> Not "always", just by default.
OK. I just copied the comment from bdrv_backing_options().
>> + qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
>> + qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
>> + } else {
>> + /* Inherit the read-only option from the parent if it's not set */
>> + qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
>> + qdict_copy_default(child_options, parent_options,
>> + BDRV_OPT_AUTO_READ_ONLY);
>> + }
>> +
>> + if (parent_is_format && !(role & BDRV_CHILD_COW)) {
>> + /*
>> + * Our format drivers take care to send flushes and respect
>> + * unmap policy, so we can default to enable both on lower
>> + * layers regardless of the corresponding parent options.
>> + */
>> + qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
>> + }
>
> Why the restriction to format here? Don't we break "unmap" propagation
> through filters with this?
Right now (before this series), the behavior seems ambiguous, in that
for filters that use bs->file, it is set, but for those that use
bs->backing, it isn’t.
But I suspect the main reason for what I did is the way I interpreted
the comment (which before this series only mentions block drivers in
general, not specifically format drivers): It sounded to me as if the
block driver needed to respect the unmap policy, and I didn’t think
filters did that. So it was my understanding that filter drivers would
just propagate discards and thus we couldn’t default-enable unmap on
their children.
But I was wrong, the block driver doesn’t need to respect anything,
because bdrv_co_pdiscard() already does.
So I suppose it should indeed be enabled for all children, with the
comment changed to express that it isn’t any block driver that respects
unmap policy, but bdrv_co_pdiscard(), e.g.:
bdrv_co_pdiscard() respects unmap policy for the parent, so we can
default to enable it on lower layers regardless of the parent option.
> It would probably also be a good question why we don't propagate it to
> the backing file, but this is preexisting.
I suppose we should, although it’s irrelevant, so. I suppose I’ll just
drop the parent_is_format, adjust the comment and that should be fine
for this series.
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 09/33] block: Add generic bdrv_inherited_options()
2020-05-07 8:49 ` Max Reitz
@ 2020-05-07 11:19 ` Kevin Wolf
2020-05-07 11:34 ` Max Reitz
0 siblings, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-07 11:19 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
[-- Attachment #1: Type: text/plain, Size: 4277 bytes --]
Am 07.05.2020 um 10:49 hat Max Reitz geschrieben:
> On 06.05.20 12:37, Kevin Wolf wrote:
> > Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> >> + if (role & BDRV_CHILD_COW) {
> >> + /* backing files are always opened read-only */
> >
> > Not "always", just by default.
>
> OK. I just copied the comment from bdrv_backing_options().
Yes, sorry, I noticed this only later (it's how review goes when a move
is split into a copy in one patch and a removal later). I don't insist
on a change if you prefer to have a clean copy.
> >> + qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
> >> + qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
> >> + } else {
> >> + /* Inherit the read-only option from the parent if it's not set */
> >> + qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
> >> + qdict_copy_default(child_options, parent_options,
> >> + BDRV_OPT_AUTO_READ_ONLY);
> >> + }
> >> +
> >> + if (parent_is_format && !(role & BDRV_CHILD_COW)) {
> >> + /*
> >> + * Our format drivers take care to send flushes and respect
> >> + * unmap policy, so we can default to enable both on lower
> >> + * layers regardless of the corresponding parent options.
> >> + */
> >> + qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
> >> + }
> >
> > Why the restriction to format here? Don't we break "unmap" propagation
> > through filters with this?
>
> Right now (before this series), the behavior seems ambiguous, in that
> for filters that use bs->file, it is set, but for those that use
> bs->backing, it isn’t.
It's probably easy to agree that this is a bug.
> But I suspect the main reason for what I did is the way I interpreted
> the comment (which before this series only mentions block drivers in
> general, not specifically format drivers): It sounded to me as if the
> block driver needed to respect the unmap policy, and I didn’t think
> filters did that. So it was my understanding that filter drivers would
> just propagate discards and thus we couldn’t default-enable unmap on
> their children.
This was actually my thought as well. And in order to propagate, we have
to copy the option from parent_options, no? Currently it will always be
disabled (unless specified explicitly for the node) because that's the
default setting for unmap.
> But I was wrong, the block driver doesn’t need to respect anything,
> because bdrv_co_pdiscard() already does.
>
> So I suppose it should indeed be enabled for all children, with the
> comment changed to express that it isn’t any block driver that respects
> unmap policy, but bdrv_co_pdiscard(), e.g.:
>
> bdrv_co_pdiscard() respects unmap policy for the parent, so we can
> default to enable it on lower layers regardless of the parent option.
This would restore the behaviour before this series for child_file and
child_format. It would be different in that it also enables "unmap" for
backing files, which should be okay.
> > It would probably also be a good question why we don't propagate it to
> > the backing file, but this is preexisting.
>
> I suppose we should, although it’s irrelevant, so. I suppose I’ll just
> drop the parent_is_format, adjust the comment and that should be fine
> for this series.
Isn't it relevant for zero writes during active commit? (The "normal"
intermediate commit job doesn't even try to optimise zero blocks...)
The job will have its own BdrvChild to access the node, but option
inheritance happens only from the parent that "owns" the backing file,
so if a qcow2 image doesn't set "unmap" on its COW child, unmap will be
disabled for the active commit job, too.
(Oops. Turns out that it's not the case because the 'unmap' option for
the job exists only for drive-mirror. blockdev-mirror passes true
unconditionally and block-commit passes false unconditionally. I'm
always amazed how consistently we fail to be consistent.
But I think using zero writes with MAY_UNMAP in a commit job is an
obvious extension, so considering it now can't hurt anyway.)
Kevin
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 09/33] block: Add generic bdrv_inherited_options()
2020-05-07 11:19 ` Kevin Wolf
@ 2020-05-07 11:34 ` Max Reitz
0 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-05-07 11:34 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 4481 bytes --]
On 07.05.20 13:19, Kevin Wolf wrote:
> Am 07.05.2020 um 10:49 hat Max Reitz geschrieben:
>> On 06.05.20 12:37, Kevin Wolf wrote:
>>> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>>>> + if (role & BDRV_CHILD_COW) {
>>>> + /* backing files are always opened read-only */
>>>
>>> Not "always", just by default.
>>
>> OK. I just copied the comment from bdrv_backing_options().
>
> Yes, sorry, I noticed this only later (it's how review goes when a move
> is split into a copy in one patch and a removal later). I don't insist
> on a change if you prefer to have a clean copy.
>
>>>> + qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
>>>> + qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
>>>> + } else {
>>>> + /* Inherit the read-only option from the parent if it's not set */
>>>> + qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
>>>> + qdict_copy_default(child_options, parent_options,
>>>> + BDRV_OPT_AUTO_READ_ONLY);
>>>> + }
>>>> +
>>>> + if (parent_is_format && !(role & BDRV_CHILD_COW)) {
>>>> + /*
>>>> + * Our format drivers take care to send flushes and respect
>>>> + * unmap policy, so we can default to enable both on lower
>>>> + * layers regardless of the corresponding parent options.
>>>> + */
>>>> + qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
>>>> + }
>>>
>>> Why the restriction to format here? Don't we break "unmap" propagation
>>> through filters with this?
>>
>> Right now (before this series), the behavior seems ambiguous, in that
>> for filters that use bs->file, it is set, but for those that use
>> bs->backing, it isn’t.
>
> It's probably easy to agree that this is a bug.
>
>> But I suspect the main reason for what I did is the way I interpreted
>> the comment (which before this series only mentions block drivers in
>> general, not specifically format drivers): It sounded to me as if the
>> block driver needed to respect the unmap policy, and I didn’t think
>> filters did that. So it was my understanding that filter drivers would
>> just propagate discards and thus we couldn’t default-enable unmap on
>> their children.
>
> This was actually my thought as well. And in order to propagate, we have
> to copy the option from parent_options, no? Currently it will always be
> disabled (unless specified explicitly for the node) because that's the
> default setting for unmap.
>
>> But I was wrong, the block driver doesn’t need to respect anything,
>> because bdrv_co_pdiscard() already does.
>>
>> So I suppose it should indeed be enabled for all children, with the
>> comment changed to express that it isn’t any block driver that respects
>> unmap policy, but bdrv_co_pdiscard(), e.g.:
>>
>> bdrv_co_pdiscard() respects unmap policy for the parent, so we can
>> default to enable it on lower layers regardless of the parent option.
>
> This would restore the behaviour before this series for child_file and
> child_format. It would be different in that it also enables "unmap" for
> backing files, which should be okay.
>
>>> It would probably also be a good question why we don't propagate it to
>>> the backing file, but this is preexisting.
>>
>> I suppose we should, although it’s irrelevant, so. I suppose I’ll just
>> drop the parent_is_format, adjust the comment and that should be fine
>> for this series.
>
> Isn't it relevant for zero writes during active commit? (The "normal"
> intermediate commit job doesn't even try to optimise zero blocks...)
>
> The job will have its own BdrvChild to access the node, but option
> inheritance happens only from the parent that "owns" the backing file,
> so if a qcow2 image doesn't set "unmap" on its COW child, unmap will be
> disabled for the active commit job, too.
>
> (Oops. Turns out that it's not the case because the 'unmap' option for
> the job exists only for drive-mirror. blockdev-mirror passes true
> unconditionally and block-commit passes false unconditionally. I'm
> always amazed how consistently we fail to be consistent.
Alles kaputt :)
> But I think using zero writes with MAY_UNMAP in a commit job is an
> obvious extension, so considering it now can't hurt anyway.)
OK. So I’ll just make unmap=on the default always.
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 10/33] block: Use bdrv_inherited_options()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (8 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 09/33] block: Add generic bdrv_inherited_options() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 11/33] block: Unify bdrv_child_cb_attach() Max Reitz
` (22 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Let child_file's, child_format's, and child_backing's .inherit_options()
implementations fall back to bdrv_inherited_options() to show that it
would really work for all of these cases, if only the parents passed the
appropriate BdrvChildRole and parent_is_format values.
(Also, make bdrv_open_inherit(), the only place to explicitly call
bdrv_backing_options(), call bdrv_inherited_options() instead.)
This patch should incur only two visible changes, both for child_format
children, both of which are effectively bug fixes:
First, they no longer have discard=unmap set by default. This reason it
was set is because bdrv_inherited_fmt_options() fell through to
bdrv_protocol_options(), and that set it because "format drivers take
care to send flushes and respect unmap policy". None of the drivers
that use child_format for their children (quorum and blkverify) are
format drivers, though, so this reasoning does not apply here.
Second, they no longer have BDRV_O_NO_IO force-cleared. child_format
was used solely for children that do not store any metadata and as such
will not be accessed by their parents as long as those parents do not
receive I/O themselves. Thus, such children should inherit
BDRV_O_NO_IO.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 66 ++++++++++++---------------------------------------------
1 file changed, 14 insertions(+), 52 deletions(-)
diff --git a/block.c b/block.c
index 9179b9b604..aa54d40e4f 100644
--- a/block.c
+++ b/block.c
@@ -1002,10 +1002,9 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
* Returns the options and flags that a generic child of a BDS should
* get, based on the given options and flags for the parent BDS.
*/
-static void __attribute__((unused))
- bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
- int *child_flags, QDict *child_options,
- int parent_flags, QDict *parent_options)
+static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
+ int *child_flags, QDict *child_options,
+ int parent_flags, QDict *parent_options)
{
int flags = parent_flags;
@@ -1090,31 +1089,9 @@ static void bdrv_protocol_options(BdrvChildRole role, bool parent_is_format,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
- int flags = parent_flags;
-
- /* Enable protocol handling, disable format probing for bs->file */
- flags |= BDRV_O_PROTOCOL;
-
- /* If the cache mode isn't explicitly set, inherit direct and no-flush from
- * the parent. */
- qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
- qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
- qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
-
- /* Inherit the read-only option from the parent if it's not set */
- qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
- qdict_copy_default(child_options, parent_options, BDRV_OPT_AUTO_READ_ONLY);
-
- /* Our block drivers take care to send flushes and respect unmap policy,
- * so we can default to enable both on lower layers regardless of the
- * corresponding parent options. */
- qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
-
- /* Clear flags that only apply to the top layer */
- flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
- BDRV_O_NO_IO);
-
- *child_flags = flags;
+ bdrv_inherited_options(BDRV_CHILD_IMAGE, true,
+ child_flags, child_options,
+ parent_flags, parent_options);
}
const BdrvChildClass child_file = {
@@ -1141,11 +1118,9 @@ static void bdrv_inherited_fmt_options(BdrvChildRole role,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
- child_file.inherit_options(role, parent_is_format,
- child_flags, child_options,
- parent_flags, parent_options);
-
- *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
+ bdrv_inherited_options(BDRV_CHILD_DATA, false,
+ child_flags, child_options,
+ parent_flags, parent_options);
}
const BdrvChildClass child_format = {
@@ -1227,23 +1202,9 @@ static void bdrv_backing_options(BdrvChildRole role, bool parent_is_format,
int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
- int flags = parent_flags;
-
- /* The cache mode is inherited unmodified for backing files; except WCE,
- * which is only applied on the top level (BlockBackend) */
- qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
- qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
- qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
-
- /* backing files always opened read-only */
- qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
- qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
- flags &= ~BDRV_O_COPY_ON_READ;
-
- /* snapshot=on is handled on the top layer */
- flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
-
- *child_flags = flags;
+ bdrv_inherited_options(BDRV_CHILD_COW, true,
+ child_flags, child_options,
+ parent_flags, parent_options);
}
static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
@@ -3144,7 +3105,8 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
flags, options);
/* Let bdrv_backing_options() override "read-only" */
qdict_del(options, BDRV_OPT_READ_ONLY);
- bdrv_backing_options(0, true, &flags, options, flags, options);
+ bdrv_inherited_options(BDRV_CHILD_COW, true,
+ &flags, options, flags, options);
}
bs->open_flags = flags;
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 11/33] block: Unify bdrv_child_cb_attach()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (9 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 10/33] block: Use bdrv_inherited_options() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 12/33] block: Unify bdrv_child_cb_detach() Max Reitz
` (21 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Make bdrv_child_cb_attach() call bdrv_backing_attach() for children with
a COW role (and drop the reverse call from bdrv_backing_attach()), so it
can be used for any child (with a proper role set).
Because so far no child has a proper role set, we need a temporary new
callback for child_backing.attach that ensures bdrv_backing_attach() is
called for all COW children that do not have their role set yet.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/block.c b/block.c
index aa54d40e4f..3cf1293a7b 100644
--- a/block.c
+++ b/block.c
@@ -942,9 +942,16 @@ static void bdrv_child_cb_drained_end(BdrvChild *child,
bdrv_drained_end_no_poll(bs, drained_end_counter);
}
+static void bdrv_backing_attach(BdrvChild *c);
+
static void bdrv_child_cb_attach(BdrvChild *child)
{
BlockDriverState *bs = child->opaque;
+
+ if (child->role & BDRV_CHILD_COW) {
+ bdrv_backing_attach(child);
+ }
+
bdrv_apply_subtree_drain(child, bs);
}
@@ -1178,7 +1185,14 @@ static void bdrv_backing_attach(BdrvChild *c)
parent->backing_blocker);
bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
parent->backing_blocker);
+}
+/* XXX: Will be removed along with child_backing */
+static void bdrv_child_cb_attach_backing(BdrvChild *c)
+{
+ if (!(c->role & BDRV_CHILD_COW)) {
+ bdrv_backing_attach(c);
+ }
bdrv_child_cb_attach(c);
}
@@ -1237,7 +1251,7 @@ static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
const BdrvChildClass child_backing = {
.parent_is_bds = true,
.get_parent_desc = bdrv_child_get_parent_desc,
- .attach = bdrv_backing_attach,
+ .attach = bdrv_child_cb_attach_backing,
.detach = bdrv_backing_detach,
.inherit_options = bdrv_backing_options,
.drained_begin = bdrv_child_cb_drained_begin,
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 12/33] block: Unify bdrv_child_cb_detach()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (10 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 11/33] block: Unify bdrv_child_cb_attach() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-05-06 12:41 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 13/33] block: Add child_of_bds Max Reitz
` (20 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Make bdrv_child_cb_detach() call bdrv_backing_detach() for children with
a COW role (and drop the reverse call from bdrv_backing_detach()), so it
can be used for any child (with a proper role set).
Because so far no child has a proper role set, we need a temporary new
callback for child_backing.detach that ensures bdrv_backing_detach() is
called for all COW children that do not have their role set yet.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 15 ++++++++++++++-
1 file changed, 14 insertions(+), 1 deletion(-)
diff --git a/block.c b/block.c
index 3cf1293a7b..0f24546863 100644
--- a/block.c
+++ b/block.c
@@ -943,6 +943,7 @@ static void bdrv_child_cb_drained_end(BdrvChild *child,
}
static void bdrv_backing_attach(BdrvChild *c);
+static void bdrv_backing_detach(BdrvChild *c);
static void bdrv_child_cb_attach(BdrvChild *child)
{
@@ -958,6 +959,11 @@ static void bdrv_child_cb_attach(BdrvChild *child)
static void bdrv_child_cb_detach(BdrvChild *child)
{
BlockDriverState *bs = child->opaque;
+
+ if (child->role & BDRV_CHILD_COW) {
+ bdrv_backing_detach(child);
+ }
+
bdrv_unapply_subtree_drain(child, bs);
}
@@ -1204,7 +1210,14 @@ static void bdrv_backing_detach(BdrvChild *c)
bdrv_op_unblock_all(c->bs, parent->backing_blocker);
error_free(parent->backing_blocker);
parent->backing_blocker = NULL;
+}
+/* XXX: Will be removed along with child_backing */
+static void bdrv_child_cb_detach_backing(BdrvChild *c)
+{
+ if (!(c->role & BDRV_CHILD_COW)) {
+ bdrv_backing_detach(c);
+ }
bdrv_child_cb_detach(c);
}
@@ -1252,7 +1265,7 @@ const BdrvChildClass child_backing = {
.parent_is_bds = true,
.get_parent_desc = bdrv_child_get_parent_desc,
.attach = bdrv_child_cb_attach_backing,
- .detach = bdrv_backing_detach,
+ .detach = bdrv_child_cb_detach_backing,
.inherit_options = bdrv_backing_options,
.drained_begin = bdrv_child_cb_drained_begin,
.drained_poll = bdrv_child_cb_drained_poll,
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 12/33] block: Unify bdrv_child_cb_detach()
2020-02-18 12:42 ` [PATCH v3 12/33] block: Unify bdrv_child_cb_detach() Max Reitz
@ 2020-05-06 12:41 ` Kevin Wolf
2020-05-07 9:09 ` Max Reitz
0 siblings, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 12:41 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> Make bdrv_child_cb_detach() call bdrv_backing_detach() for children with
> a COW role (and drop the reverse call from bdrv_backing_detach()), so it
> can be used for any child (with a proper role set).
>
> Because so far no child has a proper role set, we need a temporary new
> callback for child_backing.detach that ensures bdrv_backing_detach() is
> called for all COW children that do not have their role set yet.
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> Reviewed-by: Eric Blake <eblake@redhat.com>
> ---
> block.c | 15 ++++++++++++++-
> 1 file changed, 14 insertions(+), 1 deletion(-)
>
> diff --git a/block.c b/block.c
> index 3cf1293a7b..0f24546863 100644
> --- a/block.c
> +++ b/block.c
> @@ -943,6 +943,7 @@ static void bdrv_child_cb_drained_end(BdrvChild *child,
> }
>
> static void bdrv_backing_attach(BdrvChild *c);
> +static void bdrv_backing_detach(BdrvChild *c);
This series leaves a few static forward declarations behind, and even
in the middle of the code rather than at the top.
Does anything stop us from adding bdrv_inherited_options() after all the
old functions instead? This will require a temporary forward
declaration, too, but it can go away at the end of the series when there
is only child_of_bds left.
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 12/33] block: Unify bdrv_child_cb_detach()
2020-05-06 12:41 ` Kevin Wolf
@ 2020-05-07 9:09 ` Max Reitz
0 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-05-07 9:09 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 1653 bytes --]
On 06.05.20 14:41, Kevin Wolf wrote:
> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>> Make bdrv_child_cb_detach() call bdrv_backing_detach() for children with
>> a COW role (and drop the reverse call from bdrv_backing_detach()), so it
>> can be used for any child (with a proper role set).
>>
>> Because so far no child has a proper role set, we need a temporary new
>> callback for child_backing.detach that ensures bdrv_backing_detach() is
>> called for all COW children that do not have their role set yet.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> Reviewed-by: Eric Blake <eblake@redhat.com>
>> ---
>> block.c | 15 ++++++++++++++-
>> 1 file changed, 14 insertions(+), 1 deletion(-)
>>
>> diff --git a/block.c b/block.c
>> index 3cf1293a7b..0f24546863 100644
>> --- a/block.c
>> +++ b/block.c
>> @@ -943,6 +943,7 @@ static void bdrv_child_cb_drained_end(BdrvChild *child,
>> }
>>
>> static void bdrv_backing_attach(BdrvChild *c);
>> +static void bdrv_backing_detach(BdrvChild *c);
>
> This series leaves a few static forward declarations behind, and even
> in the middle of the code rather than at the top.
>
> Does anything stop us from adding bdrv_inherited_options() after all the
> old functions instead? This will require a temporary forward
> declaration, too, but it can go away at the end of the series when there
> is only child_of_bds left.
Personally, I have nothing against forward declarations, although they
probably should reside at the top, yes.
I suppose I can indeed just put the whole code after all the current
code (i.e., behind child_backing), though.
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 13/33] block: Add child_of_bds
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (11 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 12/33] block: Unify bdrv_child_cb_detach() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-05-06 12:59 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 14/33] block: Distinguish paths in *_format_default_perms Max Reitz
` (19 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Any current user of child_file, child_format, and child_backing can and
should use this generic BdrvChildClass instead, as it can handle all of
these cases. However, to be able to do so, the users must pass the
appropriate BdrvChildRole when the child is created/attached. (The
following commits will take care of that.)
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 27 +++++++++++++++++++++++++++
include/block/block_int.h | 1 +
2 files changed, 28 insertions(+)
diff --git a/block.c b/block.c
index 0f24546863..1d33f58ff8 100644
--- a/block.c
+++ b/block.c
@@ -1094,6 +1094,33 @@ static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
*child_flags = flags;
}
+static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
+ const char *filename, Error **errp);
+
+static int bdrv_child_cb_update_filename(BdrvChild *c, BlockDriverState *base,
+ const char *filename, Error **errp)
+{
+ if (c->role & BDRV_CHILD_COW) {
+ return bdrv_backing_update_filename(c, base, filename, errp);
+ }
+ return 0;
+}
+
+const BdrvChildClass child_of_bds = {
+ .parent_is_bds = true,
+ .get_parent_desc = bdrv_child_get_parent_desc,
+ .inherit_options = bdrv_inherited_options,
+ .drained_begin = bdrv_child_cb_drained_begin,
+ .drained_poll = bdrv_child_cb_drained_poll,
+ .drained_end = bdrv_child_cb_drained_end,
+ .attach = bdrv_child_cb_attach,
+ .detach = bdrv_child_cb_detach,
+ .inactivate = bdrv_child_cb_inactivate,
+ .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx,
+ .set_aio_ctx = bdrv_child_cb_set_aio_ctx,
+ .update_filename = bdrv_child_cb_update_filename,
+};
+
/*
* Returns the options and flags that bs->file should get if a protocol driver
* is expected, based on the given options and flags for the parent BDS
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 1f8a818f76..dd7ccea35e 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -740,6 +740,7 @@ struct BdrvChildClass {
void (*set_aio_ctx)(BdrvChild *child, AioContext *ctx, GSList **ignore);
};
+extern const BdrvChildClass child_of_bds;
extern const BdrvChildClass child_file;
extern const BdrvChildClass child_format;
extern const BdrvChildClass child_backing;
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 13/33] block: Add child_of_bds
2020-02-18 12:42 ` [PATCH v3 13/33] block: Add child_of_bds Max Reitz
@ 2020-05-06 12:59 ` Kevin Wolf
0 siblings, 0 replies; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 12:59 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> Any current user of child_file, child_format, and child_backing can and
> should use this generic BdrvChildClass instead, as it can handle all of
> these cases. However, to be able to do so, the users must pass the
> appropriate BdrvChildRole when the child is created/attached. (The
> following commits will take care of that.)
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> Reviewed-by: Eric Blake <eblake@redhat.com>
> block.c | 27 +++++++++++++++++++++++++++
> include/block/block_int.h | 1 +
> 2 files changed, 28 insertions(+)
>
> diff --git a/block.c b/block.c
> index 0f24546863..1d33f58ff8 100644
> --- a/block.c
> +++ b/block.c
> @@ -1094,6 +1094,33 @@ static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
> *child_flags = flags;
> }
>
> +static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
> + const char *filename, Error **errp);
Actually, I should have saved the comment on the previous patch for this
one. The forward declaration could easily be avoided by moving
child_of_bds down to after bdrv_backing_update_filename().
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 14/33] block: Distinguish paths in *_format_default_perms
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (12 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 13/33] block: Add child_of_bds Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 15/33] block: Pull out bdrv_default_perms_for_backing() Max Reitz
` (18 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
bdrv_format_default_perms() has one code path for backing files, and one
for storage files. We want to pull them out into own functions, so
make sure they are completely distinct before so the next patches will
be a bit cleaner.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 19 +++++++++++++------
1 file changed, 13 insertions(+), 6 deletions(-)
diff --git a/block.c b/block.c
index 1d33f58ff8..982785b15a 100644
--- a/block.c
+++ b/block.c
@@ -2331,6 +2331,13 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
perm |= BLK_PERM_CONSISTENT_READ;
}
shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
+
+ if (bs->open_flags & BDRV_O_INACTIVE) {
+ shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
+ }
+
+ *nperm = perm;
+ *nshared = shared;
} else {
/* We want consistent read from backing files if the parent needs it.
* No other operations are performed on backing files. */
@@ -2347,14 +2354,14 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
BLK_PERM_WRITE_UNCHANGED;
- }
- if (bs->open_flags & BDRV_O_INACTIVE) {
- shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
- }
+ if (bs->open_flags & BDRV_O_INACTIVE) {
+ shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
+ }
- *nperm = perm;
- *nshared = shared;
+ *nperm = perm;
+ *nshared = shared;
+ }
}
uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 15/33] block: Pull out bdrv_default_perms_for_backing()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (13 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 14/33] block: Distinguish paths in *_format_default_perms Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-05-06 13:21 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 16/33] block: Pull out bdrv_default_perms_for_storage() Max Reitz
` (17 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Right now, bdrv_format_default_perms() is used by format parents
(generally). We want to switch to a model where most parents use a
single BdrvChildClass, which then decides the permissions based on the
child role. To do so, we have to split bdrv_format_default_perms() into
separate functions for each such role.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 62 +++++++++++++++++++++++++++++++++++++--------------------
1 file changed, 40 insertions(+), 22 deletions(-)
diff --git a/block.c b/block.c
index 982785b15a..8b97412cbc 100644
--- a/block.c
+++ b/block.c
@@ -2302,6 +2302,44 @@ void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
*nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
}
+static void bdrv_default_perms_for_backing(BlockDriverState *bs, BdrvChild *c,
+ const BdrvChildClass *child_class,
+ BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
+ uint64_t perm, uint64_t shared,
+ uint64_t *nperm, uint64_t *nshared)
+{
+ assert(child_class == &child_backing ||
+ (child_class == &child_of_bds && (role & BDRV_CHILD_COW)));
+
+ /*
+ * We want consistent read from backing files if the parent needs it.
+ * No other operations are performed on backing files.
+ */
+ perm &= BLK_PERM_CONSISTENT_READ;
+
+ /*
+ * If the parent can deal with changing data, we're okay with a
+ * writable and resizable backing file.
+ * TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too?
+ */
+ if (shared & BLK_PERM_WRITE) {
+ shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
+ } else {
+ shared = 0;
+ }
+
+ shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
+ BLK_PERM_WRITE_UNCHANGED;
+
+ if (bs->open_flags & BDRV_O_INACTIVE) {
+ shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
+ }
+
+ *nperm = perm;
+ *nshared = shared;
+}
+
void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
BdrvChildRole role,
@@ -2339,28 +2377,8 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
*nperm = perm;
*nshared = shared;
} else {
- /* We want consistent read from backing files if the parent needs it.
- * No other operations are performed on backing files. */
- perm &= BLK_PERM_CONSISTENT_READ;
-
- /* If the parent can deal with changing data, we're okay with a
- * writable and resizable backing file. */
- /* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */
- if (shared & BLK_PERM_WRITE) {
- shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
- } else {
- shared = 0;
- }
-
- shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
- BLK_PERM_WRITE_UNCHANGED;
-
- if (bs->open_flags & BDRV_O_INACTIVE) {
- shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
- }
-
- *nperm = perm;
- *nshared = shared;
+ bdrv_default_perms_for_backing(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
}
}
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 15/33] block: Pull out bdrv_default_perms_for_backing()
2020-02-18 12:42 ` [PATCH v3 15/33] block: Pull out bdrv_default_perms_for_backing() Max Reitz
@ 2020-05-06 13:21 ` Kevin Wolf
2020-05-07 9:19 ` Max Reitz
0 siblings, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 13:21 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> Right now, bdrv_format_default_perms() is used by format parents
> (generally). We want to switch to a model where most parents use a
> single BdrvChildClass, which then decides the permissions based on the
> child role. To do so, we have to split bdrv_format_default_perms() into
> separate functions for each such role.
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> Reviewed-by: Eric Blake <eblake@redhat.com>
As you want to call this based on the child role, would
bdrv_default_perms_for_cow() be a more obvious name?
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 16/33] block: Pull out bdrv_default_perms_for_storage()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (14 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 15/33] block: Pull out bdrv_default_perms_for_backing() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 17/33] block: Split bdrv_default_perms_for_storage() Max Reitz
` (16 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Right now, bdrv_format_default_perms() is used by format parents
(generally). We want to switch to a model where most parents use a
single BdrvChildClass, which then decides the permissions based on the
child role. To do so, we have to split bdrv_format_default_perms() into
separate functions for each such role.
Note that bdrv_default_perms_for_storage() currently handles all DATA |
METADATA children. A follow-up patch is going to split it further into
one function for each case.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 71 +++++++++++++++++++++++++++++++++++++--------------------
1 file changed, 46 insertions(+), 25 deletions(-)
diff --git a/block.c b/block.c
index 8b97412cbc..64b5635122 100644
--- a/block.c
+++ b/block.c
@@ -2340,6 +2340,50 @@ static void bdrv_default_perms_for_backing(BlockDriverState *bs, BdrvChild *c,
*nshared = shared;
}
+static void bdrv_default_perms_for_storage(BlockDriverState *bs, BdrvChild *c,
+ const BdrvChildClass *child_class,
+ BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
+ uint64_t perm, uint64_t shared,
+ uint64_t *nperm, uint64_t *nshared)
+{
+ int flags;
+
+ assert(child_class == &child_file ||
+ (child_class == &child_of_bds &&
+ (role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA))));
+
+ flags = bdrv_reopen_get_flags(reopen_queue, bs);
+
+ /*
+ * Apart from the modifications below, the same permissions are
+ * forwarded and left alone as for filters
+ */
+ bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, &perm, &shared);
+
+ /* Format drivers may touch metadata even if the guest doesn't write */
+ if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
+ perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
+ }
+
+ /*
+ * bs->file always needs to be consistent because of the metadata. We
+ * can never allow other users to resize or write to it.
+ */
+ if (!(flags & BDRV_O_NO_IO)) {
+ perm |= BLK_PERM_CONSISTENT_READ;
+ }
+ shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
+
+ if (bs->open_flags & BDRV_O_INACTIVE) {
+ shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
+ }
+
+ *nperm = perm;
+ *nshared = shared;
+}
+
void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
BdrvChildRole role,
@@ -2351,31 +2395,8 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
assert(child_class == &child_backing || child_class == &child_file);
if (!backing) {
- int flags = bdrv_reopen_get_flags(reopen_queue, bs);
-
- /* Apart from the modifications below, the same permissions are
- * forwarded and left alone as for filters */
- bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
- perm, shared, &perm, &shared);
-
- /* Format drivers may touch metadata even if the guest doesn't write */
- if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
- perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
- }
-
- /* bs->file always needs to be consistent because of the metadata. We
- * can never allow other users to resize or write to it. */
- if (!(flags & BDRV_O_NO_IO)) {
- perm |= BLK_PERM_CONSISTENT_READ;
- }
- shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
-
- if (bs->open_flags & BDRV_O_INACTIVE) {
- shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
- }
-
- *nperm = perm;
- *nshared = shared;
+ bdrv_default_perms_for_storage(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
} else {
bdrv_default_perms_for_backing(bs, c, child_class, role, reopen_queue,
perm, shared, nperm, nshared);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 17/33] block: Split bdrv_default_perms_for_storage()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (15 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 16/33] block: Pull out bdrv_default_perms_for_storage() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 18/33] block: Add bdrv_default_perms() Max Reitz
` (15 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
We can be less restrictive about pure data children than those with
metadata on them.
For bdrv_format_default_perms(), we keep the safe option of
bdrv_default_perms_for_metadata() (until we drop
bdrv_format_default_perms() altogether).
That means that bdrv_default_perms_for_data() is unused at this point.
We will use it for all children that have the DATA role, but not the
METADATA role. So far, no child has any role, so we do not use it, but
that will change.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 53 +++++++++++++++++++++++++++++++++++++++++++----------
1 file changed, 43 insertions(+), 10 deletions(-)
diff --git a/block.c b/block.c
index 64b5635122..c0ba274743 100644
--- a/block.c
+++ b/block.c
@@ -2340,18 +2340,17 @@ static void bdrv_default_perms_for_backing(BlockDriverState *bs, BdrvChild *c,
*nshared = shared;
}
-static void bdrv_default_perms_for_storage(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
- BdrvChildRole role,
- BlockReopenQueue *reopen_queue,
- uint64_t perm, uint64_t shared,
- uint64_t *nperm, uint64_t *nshared)
+static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
+ const BdrvChildClass *child_class,
+ BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
+ uint64_t perm, uint64_t shared,
+ uint64_t *nperm, uint64_t *nshared)
{
int flags;
assert(child_class == &child_file ||
- (child_class == &child_of_bds &&
- (role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA))));
+ (child_class == &child_of_bds && (role & BDRV_CHILD_METADATA)));
flags = bdrv_reopen_get_flags(reopen_queue, bs);
@@ -2384,6 +2383,40 @@ static void bdrv_default_perms_for_storage(BlockDriverState *bs, BdrvChild *c,
*nshared = shared;
}
+/* TODO: Use */
+static void __attribute__((unused))
+bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
+ const BdrvChildClass *child_class,
+ BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
+ uint64_t perm, uint64_t shared,
+ uint64_t *nperm, uint64_t *nshared)
+{
+ assert(child_class == &child_of_bds && (role & BDRV_CHILD_DATA));
+
+ /*
+ * Apart from the modifications below, the same permissions are
+ * forwarded and left alone as for filters
+ */
+ bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, &perm, &shared);
+
+ /*
+ * We cannot allow other users to resize the file because the
+ * format driver might have some assumptions about the size
+ * (e.g. because it is stored in metadata, or because the file is
+ * split into fixed-size data files).
+ */
+ shared &= ~BLK_PERM_RESIZE;
+
+ if (bs->open_flags & BDRV_O_INACTIVE) {
+ shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
+ }
+
+ *nperm = perm;
+ *nshared = shared;
+}
+
void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class,
BdrvChildRole role,
@@ -2395,8 +2428,8 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
assert(child_class == &child_backing || child_class == &child_file);
if (!backing) {
- bdrv_default_perms_for_storage(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
+ bdrv_default_perms_for_metadata(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
} else {
bdrv_default_perms_for_backing(bs, c, child_class, role, reopen_queue,
perm, shared, nperm, nshared);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 18/33] block: Add bdrv_default_perms()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (16 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 17/33] block: Split bdrv_default_perms_for_storage() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-05-06 13:47 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 19/33] raw-format: Split raw_read_options() Max Reitz
` (14 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
This callback can be used by BDSs that use child_of_bds with the
appropriate BdrvChildRole for their children.
Also, make bdrv_format_default_perms() use it for child_of_bds children
(just a temporary solution until we can drop bdrv_format_default_perms()
altogether).
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 46 ++++++++++++++++++++++++++++++++-------
include/block/block_int.h | 11 ++++++++++
2 files changed, 49 insertions(+), 8 deletions(-)
diff --git a/block.c b/block.c
index c0ba274743..3e5b0bc345 100644
--- a/block.c
+++ b/block.c
@@ -2383,14 +2383,12 @@ static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
*nshared = shared;
}
-/* TODO: Use */
-static void __attribute__((unused))
-bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
- BdrvChildRole role,
- BlockReopenQueue *reopen_queue,
- uint64_t perm, uint64_t shared,
- uint64_t *nperm, uint64_t *nshared)
+static void bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
+ const BdrvChildClass *child_class,
+ BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
+ uint64_t perm, uint64_t shared,
+ uint64_t *nperm, uint64_t *nshared)
{
assert(child_class == &child_of_bds && (role & BDRV_CHILD_DATA));
@@ -2425,6 +2423,13 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
uint64_t *nperm, uint64_t *nshared)
{
bool backing = (child_class == &child_backing);
+
+ if (child_class == &child_of_bds) {
+ bdrv_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
+ return;
+ }
+
assert(child_class == &child_backing || child_class == &child_file);
if (!backing) {
@@ -2436,6 +2441,31 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
}
}
+void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
+ const BdrvChildClass *child_class, BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
+ uint64_t perm, uint64_t shared,
+ uint64_t *nperm, uint64_t *nshared)
+{
+ assert(child_class == &child_of_bds);
+
+ if (role & BDRV_CHILD_FILTERED) {
+ bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
+ } else if (role & BDRV_CHILD_COW) {
+ bdrv_default_perms_for_backing(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
+ } else if (role & BDRV_CHILD_METADATA) {
+ bdrv_default_perms_for_metadata(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
+ } else if (role & BDRV_CHILD_DATA) {
+ bdrv_default_perms_for_data(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
+ } else {
+ g_assert_not_reached();
+ }
+}
+
uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)
{
static const uint64_t permissions[] = {
diff --git a/include/block/block_int.h b/include/block/block_int.h
index dd7ccea35e..d1d1af2a5c 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -1279,6 +1279,17 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
bool bdrv_recurse_can_replace(BlockDriverState *bs,
BlockDriverState *to_replace);
+/*
+ * Default implementation for BlockDriver.bdrv_child_perm() that can
+ * be used by block filters and image formats, as long as they use the
+ * child_of_bds child class and set an appropriate BdrvChildRole.
+ */
+void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
+ const BdrvChildClass *child_class, BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
+ uint64_t perm, uint64_t shared,
+ uint64_t *nperm, uint64_t *nshared);
+
/*
* Default implementation for drivers to pass bdrv_co_block_status() to
* their file.
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 18/33] block: Add bdrv_default_perms()
2020-02-18 12:42 ` [PATCH v3 18/33] block: Add bdrv_default_perms() Max Reitz
@ 2020-05-06 13:47 ` Kevin Wolf
2020-05-07 9:26 ` Max Reitz
0 siblings, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 13:47 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> This callback can be used by BDSs that use child_of_bds with the
> appropriate BdrvChildRole for their children.
>
> Also, make bdrv_format_default_perms() use it for child_of_bds children
> (just a temporary solution until we can drop bdrv_format_default_perms()
> altogether).
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> Reviewed-by: Eric Blake <eblake@redhat.com>
> ---
> block.c | 46 ++++++++++++++++++++++++++++++++-------
> include/block/block_int.h | 11 ++++++++++
> 2 files changed, 49 insertions(+), 8 deletions(-)
>
> diff --git a/block.c b/block.c
> index c0ba274743..3e5b0bc345 100644
> --- a/block.c
> +++ b/block.c
> @@ -2383,14 +2383,12 @@ static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
> *nshared = shared;
> }
>
> -/* TODO: Use */
> -static void __attribute__((unused))
> -bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
> - const BdrvChildClass *child_class,
> - BdrvChildRole role,
> - BlockReopenQueue *reopen_queue,
> - uint64_t perm, uint64_t shared,
> - uint64_t *nperm, uint64_t *nshared)
> +static void bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
> + const BdrvChildClass *child_class,
> + BdrvChildRole role,
> + BlockReopenQueue *reopen_queue,
> + uint64_t perm, uint64_t shared,
> + uint64_t *nperm, uint64_t *nshared)
> {
> assert(child_class == &child_of_bds && (role & BDRV_CHILD_DATA));
>
> @@ -2425,6 +2423,13 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
> uint64_t *nperm, uint64_t *nshared)
> {
> bool backing = (child_class == &child_backing);
> +
> + if (child_class == &child_of_bds) {
> + bdrv_default_perms(bs, c, child_class, role, reopen_queue,
> + perm, shared, nperm, nshared);
> + return;
> + }
> +
> assert(child_class == &child_backing || child_class == &child_file);
>
> if (!backing) {
> @@ -2436,6 +2441,31 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
> }
> }
>
> +void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
> + const BdrvChildClass *child_class, BdrvChildRole role,
> + BlockReopenQueue *reopen_queue,
> + uint64_t perm, uint64_t shared,
> + uint64_t *nperm, uint64_t *nshared)
> +{
> + assert(child_class == &child_of_bds);
> +
> + if (role & BDRV_CHILD_FILTERED) {
> + bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
> + perm, shared, nperm, nshared);
> + } else if (role & BDRV_CHILD_COW) {
> + bdrv_default_perms_for_backing(bs, c, child_class, role, reopen_queue,
> + perm, shared, nperm, nshared);
> + } else if (role & BDRV_CHILD_METADATA) {
> + bdrv_default_perms_for_metadata(bs, c, child_class, role, reopen_queue,
> + perm, shared, nperm, nshared);
> + } else if (role & BDRV_CHILD_DATA) {
> + bdrv_default_perms_for_data(bs, c, child_class, role, reopen_queue,
> + perm, shared, nperm, nshared);
> + } else {
> + g_assert_not_reached();
> + }
> +}
Here the discussion from the start of the series becomes relevant: Which
flags can be combined with which other flags, and if multiple flags are
set, which one takes precedence?
First undocumented requirement: You must set at least one of FILTERED,
COW, METADATA and DATA.
Then, for FILTERED we decided to document that DATA shouldn't be set at
the same time. I guess neither should COW and METADATA. Apart for
documentation, worth an assertion?
COW seems to be exclusive in practice, too. I guess you could construct
a driver that somehow keeps its own (meta)data in its backing file,
maybe in the VM state area. It also sounds like a really bad idea. So
forbid it, document it and assert it, too?
METADATA and DATA can be set at the same time. As your previous patch
shows, the function for DATA is a laxer version of the one for METADATA,
requesting a subset of the METADATA permissions and sharing a superset.
So the order in the code makes sense.
But can we make sure that this condition will be true in the future?
Imagine we find a need for a new permission that is used for data files,
but not for metadata. I think at the very least, this deserves a
comment. But probably it means that both should stay a single function
that can check each flag for the exact permission bits it influences.
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 18/33] block: Add bdrv_default_perms()
2020-05-06 13:47 ` Kevin Wolf
@ 2020-05-07 9:26 ` Max Reitz
0 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-05-07 9:26 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 5553 bytes --]
On 06.05.20 15:47, Kevin Wolf wrote:
> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>> This callback can be used by BDSs that use child_of_bds with the
>> appropriate BdrvChildRole for their children.
>>
>> Also, make bdrv_format_default_perms() use it for child_of_bds children
>> (just a temporary solution until we can drop bdrv_format_default_perms()
>> altogether).
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> Reviewed-by: Eric Blake <eblake@redhat.com>
>> ---
>> block.c | 46 ++++++++++++++++++++++++++++++++-------
>> include/block/block_int.h | 11 ++++++++++
>> 2 files changed, 49 insertions(+), 8 deletions(-)
>>
>> diff --git a/block.c b/block.c
>> index c0ba274743..3e5b0bc345 100644
>> --- a/block.c
>> +++ b/block.c
>> @@ -2383,14 +2383,12 @@ static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
>> *nshared = shared;
>> }
>>
>> -/* TODO: Use */
>> -static void __attribute__((unused))
>> -bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
>> - const BdrvChildClass *child_class,
>> - BdrvChildRole role,
>> - BlockReopenQueue *reopen_queue,
>> - uint64_t perm, uint64_t shared,
>> - uint64_t *nperm, uint64_t *nshared)
>> +static void bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
>> + const BdrvChildClass *child_class,
>> + BdrvChildRole role,
>> + BlockReopenQueue *reopen_queue,
>> + uint64_t perm, uint64_t shared,
>> + uint64_t *nperm, uint64_t *nshared)
>> {
>> assert(child_class == &child_of_bds && (role & BDRV_CHILD_DATA));
>>
>> @@ -2425,6 +2423,13 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
>> uint64_t *nperm, uint64_t *nshared)
>> {
>> bool backing = (child_class == &child_backing);
>> +
>> + if (child_class == &child_of_bds) {
>> + bdrv_default_perms(bs, c, child_class, role, reopen_queue,
>> + perm, shared, nperm, nshared);
>> + return;
>> + }
>> +
>> assert(child_class == &child_backing || child_class == &child_file);
>>
>> if (!backing) {
>> @@ -2436,6 +2441,31 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
>> }
>> }
>>
>> +void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
>> + const BdrvChildClass *child_class, BdrvChildRole role,
>> + BlockReopenQueue *reopen_queue,
>> + uint64_t perm, uint64_t shared,
>> + uint64_t *nperm, uint64_t *nshared)
>> +{
>> + assert(child_class == &child_of_bds);
>> +
>> + if (role & BDRV_CHILD_FILTERED) {
>> + bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
>> + perm, shared, nperm, nshared);
>> + } else if (role & BDRV_CHILD_COW) {
>> + bdrv_default_perms_for_backing(bs, c, child_class, role, reopen_queue,
>> + perm, shared, nperm, nshared);
>> + } else if (role & BDRV_CHILD_METADATA) {
>> + bdrv_default_perms_for_metadata(bs, c, child_class, role, reopen_queue,
>> + perm, shared, nperm, nshared);
>> + } else if (role & BDRV_CHILD_DATA) {
>> + bdrv_default_perms_for_data(bs, c, child_class, role, reopen_queue,
>> + perm, shared, nperm, nshared);
>> + } else {
>> + g_assert_not_reached();
>> + }
>> +}
>
> Here the discussion from the start of the series becomes relevant: Which
> flags can be combined with which other flags, and if multiple flags are
> set, which one takes precedence?
>
> First undocumented requirement: You must set at least one of FILTERED,
> COW, METADATA and DATA.
>
> Then, for FILTERED we decided to document that DATA shouldn't be set at
> the same time. I guess neither should COW and METADATA. Apart for
> documentation, worth an assertion?
>
> COW seems to be exclusive in practice, too. I guess you could construct
> a driver that somehow keeps its own (meta)data in its backing file,
> maybe in the VM state area. It also sounds like a really bad idea. So
> forbid it, document it and assert it, too?
Sounds all good.
> METADATA and DATA can be set at the same time. As your previous patch
> shows, the function for DATA is a laxer version of the one for METADATA,
> requesting a subset of the METADATA permissions and sharing a superset.
> So the order in the code makes sense.
>
> But can we make sure that this condition will be true in the future?
> Imagine we find a need for a new permission that is used for data files,
> but not for metadata. I think at the very least, this deserves a
> comment. But probably it means that both should stay a single function
> that can check each flag for the exact permission bits it influences.
Maybe, I’ll see whether it looks good. If it doesn’t, I could also
rename the _metadata function to _storage, so that it’s generally a
function that handles metadata+data children (i.e. defined to be
stricter than the _data function).
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 19/33] raw-format: Split raw_read_options()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (17 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 18/33] block: Add bdrv_default_perms() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 20/33] block: Switch child_format users to child_of_bds Max Reitz
` (13 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Split raw_read_options() into one function that actually just reads the
options, and another that applies them. This will allow us to detect
whether the user has specified any options before attaching the file
child (so we can decide on its role based on the options).
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block/raw-format.c | 110 ++++++++++++++++++++++++++-------------------
1 file changed, 65 insertions(+), 45 deletions(-)
diff --git a/block/raw-format.c b/block/raw-format.c
index b600dae209..33f5942474 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -71,20 +71,13 @@ static QemuOptsList raw_create_opts = {
}
};
-static int raw_read_options(QDict *options, BlockDriverState *bs,
- BDRVRawState *s, Error **errp)
+static int raw_read_options(QDict *options, uint64_t *offset, bool *has_size,
+ uint64_t *size, Error **errp)
{
Error *local_err = NULL;
QemuOpts *opts = NULL;
- int64_t real_size = 0;
int ret;
- real_size = bdrv_getlength(bs->file->bs);
- if (real_size < 0) {
- error_setg_errno(errp, -real_size, "Could not get image size");
- return real_size;
- }
-
opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
@@ -93,64 +86,84 @@ static int raw_read_options(QDict *options, BlockDriverState *bs,
goto end;
}
- s->offset = qemu_opt_get_size(opts, "offset", 0);
- if (s->offset > real_size) {
- error_setg(errp, "Offset (%" PRIu64 ") cannot be greater than "
- "size of the containing file (%" PRId64 ")",
- s->offset, real_size);
- ret = -EINVAL;
- goto end;
- }
+ *offset = qemu_opt_get_size(opts, "offset", 0);
+ *has_size = qemu_opt_find(opts, "size");
+ *size = qemu_opt_get_size(opts, "size", 0);
- if (qemu_opt_find(opts, "size") != NULL) {
- s->size = qemu_opt_get_size(opts, "size", 0);
- s->has_size = true;
- } else {
- s->has_size = false;
- s->size = real_size - s->offset;
+ ret = 0;
+end:
+ qemu_opts_del(opts);
+ return ret;
+}
+
+static int raw_apply_options(BlockDriverState *bs, BDRVRawState *s,
+ uint64_t offset, bool has_size, uint64_t size,
+ Error **errp)
+{
+ int64_t real_size = 0;
+
+ real_size = bdrv_getlength(bs->file->bs);
+ if (real_size < 0) {
+ error_setg_errno(errp, -real_size, "Could not get image size");
+ return real_size;
}
/* Check size and offset */
- if ((real_size - s->offset) < s->size) {
+ if (offset > real_size) {
+ error_setg(errp, "Offset (%" PRIu64 ") cannot be greater than "
+ "size of the containing file (%" PRId64 ")",
+ s->offset, real_size);
+ return -EINVAL;
+ }
+
+ if (has_size && (real_size - offset) < size) {
error_setg(errp, "The sum of offset (%" PRIu64 ") and size "
- "(%" PRIu64 ") has to be smaller or equal to the "
- " actual size of the containing file (%" PRId64 ")",
- s->offset, s->size, real_size);
- ret = -EINVAL;
- goto end;
+ "(%" PRIu64 ") has to be smaller or equal to the "
+ " actual size of the containing file (%" PRId64 ")",
+ s->offset, s->size, real_size);
+ return -EINVAL;
}
/* Make sure size is multiple of BDRV_SECTOR_SIZE to prevent rounding
* up and leaking out of the specified area. */
- if (s->has_size && !QEMU_IS_ALIGNED(s->size, BDRV_SECTOR_SIZE)) {
+ if (has_size && !QEMU_IS_ALIGNED(size, BDRV_SECTOR_SIZE)) {
error_setg(errp, "Specified size is not multiple of %llu",
- BDRV_SECTOR_SIZE);
- ret = -EINVAL;
- goto end;
+ BDRV_SECTOR_SIZE);
+ return -EINVAL;
}
- ret = 0;
-
-end:
+ s->offset = offset;
+ s->has_size = has_size;
+ s->size = has_size ? size : real_size - offset;
- qemu_opts_del(opts);
-
- return ret;
+ return 0;
}
static int raw_reopen_prepare(BDRVReopenState *reopen_state,
BlockReopenQueue *queue, Error **errp)
{
+ bool has_size;
+ uint64_t offset, size;
+ int ret;
+
assert(reopen_state != NULL);
assert(reopen_state->bs != NULL);
reopen_state->opaque = g_new0(BDRVRawState, 1);
- return raw_read_options(
- reopen_state->options,
- reopen_state->bs,
- reopen_state->opaque,
- errp);
+ ret = raw_read_options(reopen_state->options, &offset, &has_size, &size,
+ errp);
+ if (ret < 0) {
+ return ret;
+ }
+
+ ret = raw_apply_options(reopen_state->bs, reopen_state->opaque,
+ offset, has_size, size, errp);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return 0;
}
static void raw_reopen_commit(BDRVReopenState *state)
@@ -429,8 +442,15 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
BDRVRawState *s = bs->opaque;
+ bool has_size;
+ uint64_t offset, size;
int ret;
+ ret = raw_read_options(options, &offset, &has_size, &size, errp);
+ if (ret < 0) {
+ return ret;
+ }
+
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
false, errp);
if (!bs->file) {
@@ -456,7 +476,7 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
bs->file->bs->filename);
}
- ret = raw_read_options(options, bs, s, errp);
+ ret = raw_apply_options(bs, s, offset, has_size, size, errp);
if (ret < 0) {
return ret;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 20/33] block: Switch child_format users to child_of_bds
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (18 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 19/33] raw-format: Split raw_read_options() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 13:10 ` Eric Blake
2020-02-18 12:42 ` [PATCH v3 21/33] block: Drop child_format Max Reitz
` (12 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Both users (quorum and blkverify) use child_format for
not-really-filtered children, so the appropriate BdrvChildRole in both
cases is DATA. (Note that this will cause bdrv_inherited_options() to
force-allow format probing.)
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
block/blkverify.c | 4 ++--
block/quorum.c | 6 ++++--
2 files changed, 6 insertions(+), 4 deletions(-)
diff --git a/block/blkverify.c b/block/blkverify.c
index ba4f6d7b7c..1684b7aa2e 100644
--- a/block/blkverify.c
+++ b/block/blkverify.c
@@ -134,8 +134,8 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags,
/* Open the test file */
s->test_file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options,
- "test", bs, &child_format, 0, false,
- &local_err);
+ "test", bs, &child_of_bds, BDRV_CHILD_DATA,
+ false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
diff --git a/block/quorum.c b/block/quorum.c
index d37b77a522..616ac3a927 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -977,7 +977,8 @@ static int quorum_open(BlockDriverState *bs, QDict *options, int flags,
assert(ret < 32);
s->children[i] = bdrv_open_child(NULL, options, indexstr, bs,
- &child_format, 0, false, &local_err);
+ &child_of_bds, BDRV_CHILD_DATA, false,
+ &local_err);
if (local_err) {
ret = -EINVAL;
goto close_exit;
@@ -1053,7 +1054,8 @@ static void quorum_add_child(BlockDriverState *bs, BlockDriverState *child_bs,
/* We can safely add the child now */
bdrv_ref(child_bs);
- child = bdrv_attach_child(bs, child_bs, indexstr, &child_format, 0, errp);
+ child = bdrv_attach_child(bs, child_bs, indexstr, &child_of_bds,
+ BDRV_CHILD_DATA, errp);
if (child == NULL) {
s->next_child_index--;
goto out;
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 20/33] block: Switch child_format users to child_of_bds
2020-02-18 12:42 ` [PATCH v3 20/33] block: Switch child_format users to child_of_bds Max Reitz
@ 2020-02-18 13:10 ` Eric Blake
0 siblings, 0 replies; 63+ messages in thread
From: Eric Blake @ 2020-02-18 13:10 UTC (permalink / raw)
To: Max Reitz, qemu-block; +Cc: Kevin Wolf, qemu-devel
On 2/18/20 6:42 AM, Max Reitz wrote:
> Both users (quorum and blkverify) use child_format for
> not-really-filtered children, so the appropriate BdrvChildRole in both
> cases is DATA. (Note that this will cause bdrv_inherited_options() to
> force-allow format probing.)
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> ---
> block/blkverify.c | 4 ++--
> block/quorum.c | 6 ++++--
> 2 files changed, 6 insertions(+), 4 deletions(-)
>
Reviewed-by: Eric Blake <eblake@redhat.com>
--
Eric Blake, Principal Software Engineer
Red Hat, Inc. +1-919-301-3226
Virtualization: qemu.org | libvirt.org
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 21/33] block: Drop child_format
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (19 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 20/33] block: Switch child_format users to child_of_bds Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 22/33] block: Make backing files child_of_bds children Max Reitz
` (11 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 29 -----------------------------
include/block/block_int.h | 1 -
2 files changed, 30 deletions(-)
diff --git a/block.c b/block.c
index 3e5b0bc345..43df38ca30 100644
--- a/block.c
+++ b/block.c
@@ -1148,35 +1148,6 @@ const BdrvChildClass child_file = {
.set_aio_ctx = bdrv_child_cb_set_aio_ctx,
};
-/*
- * Returns the options and flags that bs->file should get if the use of formats
- * (and not only protocols) is permitted for it, based on the given options and
- * flags for the parent BDS
- */
-static void bdrv_inherited_fmt_options(BdrvChildRole role,
- bool parent_is_format,
- int *child_flags, QDict *child_options,
- int parent_flags, QDict *parent_options)
-{
- bdrv_inherited_options(BDRV_CHILD_DATA, false,
- child_flags, child_options,
- parent_flags, parent_options);
-}
-
-const BdrvChildClass child_format = {
- .parent_is_bds = true,
- .get_parent_desc = bdrv_child_get_parent_desc,
- .inherit_options = bdrv_inherited_fmt_options,
- .drained_begin = bdrv_child_cb_drained_begin,
- .drained_poll = bdrv_child_cb_drained_poll,
- .drained_end = bdrv_child_cb_drained_end,
- .attach = bdrv_child_cb_attach,
- .detach = bdrv_child_cb_detach,
- .inactivate = bdrv_child_cb_inactivate,
- .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx,
- .set_aio_ctx = bdrv_child_cb_set_aio_ctx,
-};
-
static void bdrv_backing_attach(BdrvChild *c)
{
BlockDriverState *parent = c->opaque;
diff --git a/include/block/block_int.h b/include/block/block_int.h
index d1d1af2a5c..75139a95ae 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -742,7 +742,6 @@ struct BdrvChildClass {
extern const BdrvChildClass child_of_bds;
extern const BdrvChildClass child_file;
-extern const BdrvChildClass child_format;
extern const BdrvChildClass child_backing;
struct BdrvChild {
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 22/33] block: Make backing files child_of_bds children
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (20 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 21/33] block: Drop child_format Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-05-06 16:37 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 23/33] block: Drop child_backing Max Reitz
` (10 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Make all parents of backing files pass the appropriate BdrvChildRole.
By doing so, we can switch their BdrvChildClass over to the generic
child_of_bds, which will do the right thing when given a correct
BdrvChildRole.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 26 ++++++++++++++++++++------
block/backup-top.c | 2 +-
block/vvfat.c | 3 ++-
tests/test-bdrv-drain.c | 13 +++++++------
4 files changed, 30 insertions(+), 14 deletions(-)
diff --git a/block.c b/block.c
index 43df38ca30..31affcb4ee 100644
--- a/block.c
+++ b/block.c
@@ -2770,6 +2770,20 @@ static bool bdrv_inherits_from_recursive(BlockDriverState *child,
return child != NULL;
}
+/*
+ * Return the BdrvChildRole for @bs's backing child. bs->backing is
+ * mostly used for COW backing children (role = COW), but also for
+ * filtered children (role = FILTERED | PRIMARY).
+ */
+static BdrvChildRole bdrv_backing_role(BlockDriverState *bs)
+{
+ if (bs->drv && bs->drv->is_filter) {
+ return BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
+ } else {
+ return BDRV_CHILD_COW;
+ }
+}
+
/*
* Sets the backing file link of a BDS. A new reference is created; callers
* which don't need their own reference any more must call bdrv_unref().
@@ -2797,8 +2811,8 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
goto out;
}
- bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
- 0, errp);
+ bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_of_bds,
+ bdrv_backing_role(bs), errp);
/* If backing_hd was already part of bs's backing chain, and
* inherits_from pointed recursively to bs then let's update it to
* point directly to bs (else it will become NULL). */
@@ -2895,7 +2909,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
}
backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs,
- &child_backing, 0, errp);
+ &child_of_bds, BDRV_CHILD_COW, errp);
if (!backing_hd) {
bs->open_flags |= BDRV_O_NO_BACKING;
error_prepend(errp, "Could not open backing file: ");
@@ -3731,8 +3745,8 @@ int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
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, 0, bs_queue,
- state->perm, state->shared_perm,
+ NULL, &child_of_bds, bdrv_backing_role(state->bs),
+ bs_queue, state->perm, state->shared_perm,
&nperm, &nshared);
ret = bdrv_check_update_perm(state->new_backing_bs, NULL,
nperm, nshared, NULL, NULL, errp);
@@ -6679,7 +6693,7 @@ void bdrv_refresh_filename(BlockDriverState *bs)
drv->bdrv_gather_child_options(bs, opts, backing_overridden);
} else {
QLIST_FOREACH(child, &bs->children, next) {
- if (child->klass == &child_backing && !backing_overridden) {
+ if (child == bs->backing && !backing_overridden) {
/* We can skip the backing BDS if it has not been overridden */
continue;
}
diff --git a/block/backup-top.c b/block/backup-top.c
index 9dd89c2fde..c173e61250 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -142,7 +142,7 @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
return;
}
- if (child_class == &child_file) {
+ if (!(role & BDRV_CHILD_FILTERED)) {
/*
* Target child
*
diff --git a/block/vvfat.c b/block/vvfat.c
index a945eeb635..8f4ff5a97e 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3221,7 +3221,8 @@ static void vvfat_child_perm(BlockDriverState *bs, BdrvChild *c,
{
BDRVVVFATState *s = bs->opaque;
- assert(c == s->qcow || child_class == &child_backing);
+ assert(c == s->qcow ||
+ (child_class == &child_of_bds && (role & BDRV_CHILD_COW)));
if (c == s->qcow) {
/* This is a private node, nobody should try to attach to it */
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index b3d7960bd0..15393a0140 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -96,7 +96,7 @@ static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
* bdrv_format_default_perms() accepts only these two, so disguise
* detach_by_driver_cb_parent as one of them.
*/
- if (child_class != &child_file && child_class != &child_backing) {
+ if (child_class != &child_file && child_class != &child_of_bds) {
child_class = &child_file;
}
@@ -1399,8 +1399,8 @@ static void test_detach_indirect(bool by_parent_cb)
bdrv_ref(a);
child_b = bdrv_attach_child(parent_b, b, "PB-B", &child_file, 0,
&error_abort);
- child_a = bdrv_attach_child(parent_b, a, "PB-A", &child_backing, 0,
- &error_abort);
+ child_a = bdrv_attach_child(parent_b, a, "PB-A", &child_of_bds,
+ BDRV_CHILD_COW, &error_abort);
bdrv_ref(a);
bdrv_attach_child(parent_a, a, "PA-A",
@@ -1793,7 +1793,7 @@ static void test_drop_intermediate_poll(void)
int i;
int ret;
- chain_child_class = child_backing;
+ chain_child_class = child_of_bds;
chain_child_class.update_filename = drop_intermediate_poll_update_filename;
for (i = 0; i < 3; i++) {
@@ -1816,7 +1816,7 @@ static void test_drop_intermediate_poll(void)
/* Takes the reference to chain[i - 1] */
chain[i]->backing = bdrv_attach_child(chain[i], chain[i - 1],
"chain", &chain_child_class,
- 0, &error_abort);
+ BDRV_CHILD_COW, &error_abort);
}
}
@@ -2034,7 +2034,8 @@ static void do_test_replace_child_mid_drain(int old_drain_count,
bdrv_ref(old_child_bs);
parent_bs->backing = bdrv_attach_child(parent_bs, old_child_bs, "child",
- &child_backing, 0, &error_abort);
+ &child_of_bds, BDRV_CHILD_COW,
+ &error_abort);
for (i = 0; i < old_drain_count; i++) {
bdrv_drained_begin(old_child_bs);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 22/33] block: Make backing files child_of_bds children
2020-02-18 12:42 ` [PATCH v3 22/33] block: Make backing files child_of_bds children Max Reitz
@ 2020-05-06 16:37 ` Kevin Wolf
2020-05-07 9:28 ` Max Reitz
0 siblings, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 16:37 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> Make all parents of backing files pass the appropriate BdrvChildRole.
> By doing so, we can switch their BdrvChildClass over to the generic
> child_of_bds, which will do the right thing when given a correct
> BdrvChildRole.
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> Reviewed-by: Eric Blake <eblake@redhat.com>
> ---
> block.c | 26 ++++++++++++++++++++------
> block/backup-top.c | 2 +-
> block/vvfat.c | 3 ++-
> tests/test-bdrv-drain.c | 13 +++++++------
> 4 files changed, 30 insertions(+), 14 deletions(-)
>
> diff --git a/block.c b/block.c
> index 43df38ca30..31affcb4ee 100644
> --- a/block.c
> +++ b/block.c
> @@ -2770,6 +2770,20 @@ static bool bdrv_inherits_from_recursive(BlockDriverState *child,
> return child != NULL;
> }
>
> +/*
> + * Return the BdrvChildRole for @bs's backing child. bs->backing is
> + * mostly used for COW backing children (role = COW), but also for
> + * filtered children (role = FILTERED | PRIMARY).
> + */
> +static BdrvChildRole bdrv_backing_role(BlockDriverState *bs)
> +{
> + if (bs->drv && bs->drv->is_filter) {
> + return BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
> + } else {
> + return BDRV_CHILD_COW;
> + }
> +}
bdrv_mirror_top and bdrv_commit_top don't set .is_filter, so it will
return the wrong role for them. (They also don't set .supports_backing,
so grepping for that wouldn't help...)
> /*
> * Sets the backing file link of a BDS. A new reference is created; callers
> * which don't need their own reference any more must call bdrv_unref().
> @@ -2797,8 +2811,8 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
> goto out;
> }
>
> - bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
> - 0, errp);
> + bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_of_bds,
> + bdrv_backing_role(bs), errp);
> /* If backing_hd was already part of bs's backing chain, and
> * inherits_from pointed recursively to bs then let's update it to
> * point directly to bs (else it will become NULL). */
> @@ -2895,7 +2909,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
> }
>
> backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs,
> - &child_backing, 0, errp);
> + &child_of_bds, BDRV_CHILD_COW, errp);
Wouldn't it be more consistent to use bdrv_backing_role() here, too?
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread* Re: [PATCH v3 22/33] block: Make backing files child_of_bds children
2020-05-06 16:37 ` Kevin Wolf
@ 2020-05-07 9:28 ` Max Reitz
0 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-05-07 9:28 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 2951 bytes --]
On 06.05.20 18:37, Kevin Wolf wrote:
> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>> Make all parents of backing files pass the appropriate BdrvChildRole.
>> By doing so, we can switch their BdrvChildClass over to the generic
>> child_of_bds, which will do the right thing when given a correct
>> BdrvChildRole.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> Reviewed-by: Eric Blake <eblake@redhat.com>
>> ---
>> block.c | 26 ++++++++++++++++++++------
>> block/backup-top.c | 2 +-
>> block/vvfat.c | 3 ++-
>> tests/test-bdrv-drain.c | 13 +++++++------
>> 4 files changed, 30 insertions(+), 14 deletions(-)
>>
>> diff --git a/block.c b/block.c
>> index 43df38ca30..31affcb4ee 100644
>> --- a/block.c
>> +++ b/block.c
>> @@ -2770,6 +2770,20 @@ static bool bdrv_inherits_from_recursive(BlockDriverState *child,
>> return child != NULL;
>> }
>>
>> +/*
>> + * Return the BdrvChildRole for @bs's backing child. bs->backing is
>> + * mostly used for COW backing children (role = COW), but also for
>> + * filtered children (role = FILTERED | PRIMARY).
>> + */
>> +static BdrvChildRole bdrv_backing_role(BlockDriverState *bs)
>> +{
>> + if (bs->drv && bs->drv->is_filter) {
>> + return BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
>> + } else {
>> + return BDRV_CHILD_COW;
>> + }
>> +}
>
> bdrv_mirror_top and bdrv_commit_top don't set .is_filter, so it will
> return the wrong role for them. (They also don't set .supports_backing,
> so grepping for that wouldn't help...)
I’ll pull in “block: Mark commit and mirror as filter drivers” from the
main series then.
>> /*
>> * Sets the backing file link of a BDS. A new reference is created; callers
>> * which don't need their own reference any more must call bdrv_unref().
>> @@ -2797,8 +2811,8 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
>> goto out;
>> }
>>
>> - bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
>> - 0, errp);
>> + bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_of_bds,
>> + bdrv_backing_role(bs), errp);
>> /* If backing_hd was already part of bs's backing chain, and
>> * inherits_from pointed recursively to bs then let's update it to
>> * point directly to bs (else it will become NULL). */
>> @@ -2895,7 +2909,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
>> }
>>
>> backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs,
>> - &child_backing, 0, errp);
>> + &child_of_bds, BDRV_CHILD_COW, errp);
>
> Wouldn't it be more consistent to use bdrv_backing_role() here, too?
It’d be indeed.
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 23/33] block: Drop child_backing
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (21 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 22/33] block: Make backing files child_of_bds children Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 24/33] block: Make format drivers use child_of_bds Max Reitz
` (9 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 62 +++------------------------------------
include/block/block_int.h | 1 -
2 files changed, 4 insertions(+), 59 deletions(-)
diff --git a/block.c b/block.c
index 31affcb4ee..1f573f3815 100644
--- a/block.c
+++ b/block.c
@@ -1191,15 +1191,6 @@ static void bdrv_backing_attach(BdrvChild *c)
parent->backing_blocker);
}
-/* XXX: Will be removed along with child_backing */
-static void bdrv_child_cb_attach_backing(BdrvChild *c)
-{
- if (!(c->role & BDRV_CHILD_COW)) {
- bdrv_backing_attach(c);
- }
- bdrv_child_cb_attach(c);
-}
-
static void bdrv_backing_detach(BdrvChild *c)
{
BlockDriverState *parent = c->opaque;
@@ -1210,28 +1201,6 @@ static void bdrv_backing_detach(BdrvChild *c)
parent->backing_blocker = NULL;
}
-/* XXX: Will be removed along with child_backing */
-static void bdrv_child_cb_detach_backing(BdrvChild *c)
-{
- if (!(c->role & BDRV_CHILD_COW)) {
- bdrv_backing_detach(c);
- }
- bdrv_child_cb_detach(c);
-}
-
-/*
- * Returns the options and flags that bs->backing should get, based on the
- * given options and flags for the parent BDS
- */
-static void bdrv_backing_options(BdrvChildRole role, bool parent_is_format,
- int *child_flags, QDict *child_options,
- int parent_flags, QDict *parent_options)
-{
- bdrv_inherited_options(BDRV_CHILD_COW, true,
- child_flags, child_options,
- parent_flags, parent_options);
-}
-
static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
const char *filename, Error **errp)
{
@@ -1259,21 +1228,6 @@ static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
return ret;
}
-const BdrvChildClass child_backing = {
- .parent_is_bds = true,
- .get_parent_desc = bdrv_child_get_parent_desc,
- .attach = bdrv_child_cb_attach_backing,
- .detach = bdrv_child_cb_detach_backing,
- .inherit_options = bdrv_backing_options,
- .drained_begin = bdrv_child_cb_drained_begin,
- .drained_poll = bdrv_child_cb_drained_poll,
- .drained_end = bdrv_child_cb_drained_end,
- .inactivate = bdrv_child_cb_inactivate,
- .update_filename = bdrv_backing_update_filename,
- .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx,
- .set_aio_ctx = bdrv_child_cb_set_aio_ctx,
-};
-
static int bdrv_open_flags(BlockDriverState *bs, int flags)
{
int open_flags = flags;
@@ -2280,8 +2234,7 @@ static void bdrv_default_perms_for_backing(BlockDriverState *bs, BdrvChild *c,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
- assert(child_class == &child_backing ||
- (child_class == &child_of_bds && (role & BDRV_CHILD_COW)));
+ assert(child_class == &child_of_bds && (role & BDRV_CHILD_COW));
/*
* We want consistent read from backing files if the parent needs it.
@@ -2393,23 +2346,16 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
- bool backing = (child_class == &child_backing);
-
if (child_class == &child_of_bds) {
bdrv_default_perms(bs, c, child_class, role, reopen_queue,
perm, shared, nperm, nshared);
return;
}
- assert(child_class == &child_backing || child_class == &child_file);
+ assert(child_class == &child_file);
- if (!backing) {
- bdrv_default_perms_for_metadata(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
- } else {
- bdrv_default_perms_for_backing(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
- }
+ bdrv_default_perms_for_metadata(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
}
void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 75139a95ae..ab64a5ccea 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -742,7 +742,6 @@ struct BdrvChildClass {
extern const BdrvChildClass child_of_bds;
extern const BdrvChildClass child_file;
-extern const BdrvChildClass child_backing;
struct BdrvChild {
BlockDriverState *bs;
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 24/33] block: Make format drivers use child_of_bds
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (22 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 23/33] block: Drop child_backing Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 25/33] block: Make filter " Max Reitz
` (8 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Commonly, they need to pass the BDRV_CHILD_IMAGE set as the
BdrvChildRole; but there are exceptions for drivers with external data
files (qcow2 and vmdk).
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block/bochs.c | 4 ++--
block/cloop.c | 4 ++--
block/crypto.c | 4 ++--
block/dmg.c | 4 ++--
block/parallels.c | 4 ++--
block/qcow.c | 4 ++--
block/qcow2.c | 19 +++++++++++++------
block/qed.c | 4 ++--
block/vdi.c | 4 ++--
block/vhdx.c | 4 ++--
block/vmdk.c | 20 +++++++++++++++++---
block/vpc.c | 4 ++--
12 files changed, 50 insertions(+), 29 deletions(-)
diff --git a/block/bochs.c b/block/bochs.c
index b013e73063..62c3f42548 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -110,8 +110,8 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
return ret;
}
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/cloop.c b/block/cloop.c
index 3ed9fa63cc..d374a8427d 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -71,8 +71,8 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
return ret;
}
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/crypto.c b/block/crypto.c
index 4da74a7737..2d85d9e70a 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -200,8 +200,8 @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
unsigned int cflags = 0;
QDict *cryptoopts = NULL;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/dmg.c b/block/dmg.c
index af8188638c..bc64194577 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -439,8 +439,8 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
return ret;
}
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/parallels.c b/block/parallels.c
index 3d5b3b7c63..7dc9a1fa76 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -728,8 +728,8 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
Error *local_err = NULL;
char *buf;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/qcow.c b/block/qcow.c
index 2bf8e8eb36..bc7f7c1054 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -130,8 +130,8 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
qdict_extract_subqdict(options, &encryptopts, "encrypt.");
encryptfmt = qdict_get_try_str(encryptopts, "format");
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
ret = -EINVAL;
goto fail;
diff --git a/block/qcow2.c b/block/qcow2.c
index 2ce974df4d..7e1532cc5e 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -1537,8 +1537,9 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
}
/* Open external data file */
- s->data_file = bdrv_open_child(NULL, options, "data-file", bs, &child_file,
- 0, true, &local_err);
+ s->data_file = bdrv_open_child(NULL, options, "data-file", bs,
+ &child_of_bds, BDRV_CHILD_DATA,
+ true, &local_err);
if (local_err) {
error_propagate(errp, local_err);
ret = -EINVAL;
@@ -1548,8 +1549,8 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
if (!s->data_file && s->image_data_file) {
s->data_file = bdrv_open_child(s->image_data_file, options,
- "data-file", bs, &child_file, 0,
- false, errp);
+ "data-file", bs, &child_of_bds,
+ BDRV_CHILD_DATA, false, errp);
if (!s->data_file) {
ret = -EINVAL;
goto fail;
@@ -1560,6 +1561,12 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
ret = -EINVAL;
goto fail;
}
+
+ /* No data here */
+ bs->file->role &= ~BDRV_CHILD_DATA;
+
+ /* Must succeed because we have given up permissions if anything */
+ bdrv_child_refresh_perms(bs, bs->file, &error_abort);
} else {
if (s->data_file) {
error_setg(errp, "'data-file' can only be set for images with an "
@@ -1808,8 +1815,8 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
.ret = -EINPROGRESS
};
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/qed.c b/block/qed.c
index d15ba11959..d6222798c2 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -547,8 +547,8 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
.ret = -EINPROGRESS
};
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/vdi.c b/block/vdi.c
index 987e2ed592..1736d02eee 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -378,8 +378,8 @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
Error *local_err = NULL;
QemuUUID uuid_link, uuid_parent;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/vhdx.c b/block/vhdx.c
index be23290ac8..d8a315015d 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -997,8 +997,8 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
uint64_t signature;
Error *local_err = NULL;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/vmdk.c b/block/vmdk.c
index 84f99d881f..497414e5f2 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -1089,6 +1089,7 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
char *desc_file_dir = NULL;
char *extent_path;
BdrvChild *extent_file;
+ BdrvChildRole extent_role;
BDRVVmdkState *s = bs->opaque;
VmdkExtent *extent;
char extent_opt_prefix[32];
@@ -1151,8 +1152,15 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
ret = snprintf(extent_opt_prefix, 32, "extents.%d", s->num_extents);
assert(ret < 32);
+ extent_role = BDRV_CHILD_DATA;
+ if (strcmp(type, "FLAT") != 0 && strcmp(type, "VMFS") != 0) {
+ /* non-flat extents have metadata */
+ extent_role |= BDRV_CHILD_METADATA;
+ }
+
extent_file = bdrv_open_child(extent_path, options, extent_opt_prefix,
- bs, &child_file, 0, false, &local_err);
+ bs, &child_of_bds, extent_role, false,
+ &local_err);
g_free(extent_path);
if (local_err) {
error_propagate(errp, local_err);
@@ -1257,8 +1265,8 @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
uint32_t magic;
Error *local_err = NULL;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
@@ -1277,6 +1285,12 @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
s->desc_offset = 0x200;
break;
default:
+ /* No data in the descriptor file */
+ bs->file->role &= ~BDRV_CHILD_DATA;
+
+ /* Must succeed because we have given up permissions if anything */
+ bdrv_child_refresh_perms(bs, bs->file, &error_abort);
+
ret = vmdk_open_desc_file(bs, flags, buf, options, errp);
break;
}
diff --git a/block/vpc.c b/block/vpc.c
index 5378e32d1d..9acd6edac9 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -228,8 +228,8 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
int ret;
int64_t bs_size;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_IMAGE, false, errp);
if (!bs->file) {
return -EINVAL;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 25/33] block: Make filter drivers use child_of_bds
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (23 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 24/33] block: Make format drivers use child_of_bds Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 26/33] block: Use child_of_bds in remaining places Max Reitz
` (7 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Note that some filters have secondary children, namely blkverify (the
image to be verified) and blklogwrites (the log). This patch does not
touch those children.
Note that for blkverify, the filtered child should not be format-probed.
While there is nothing enforcing this here, in practice, it will not be:
blkverify implements .bdrv_file_open. The block layer ensures (and in
fact, asserts) that BDRV_O_PROTOCOL is set for every BDS whose driver
implements .bdrv_file_open. This flag will then be bequeathed to
blkverify's children, and they will thus (by default) not be probed
either.
("By default" refers to the fact that blkverify's other child (the
non-filtered one) will have BDRV_O_PROTOCOL force-unset, because that is
what happens for all non-filtered children of non-format drivers.)
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block/blkdebug.c | 4 +++-
block/blklogwrites.c | 3 ++-
block/blkverify.c | 4 +++-
block/copy-on-read.c | 5 +++--
block/filter-compress.c | 5 +++--
block/replication.c | 3 ++-
block/throttle.c | 5 +++--
7 files changed, 19 insertions(+), 10 deletions(-)
diff --git a/block/blkdebug.c b/block/blkdebug.c
index 8dd8ed6055..b31fa40b0e 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -497,7 +497,9 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
/* Open the image file */
bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image",
- bs, &child_file, 0, false, &local_err);
+ bs, &child_of_bds,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
+ false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index 4faf912ef1..78b0c49460 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -157,7 +157,8 @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
}
/* Open the file */
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0, false,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, false,
&local_err);
if (local_err) {
ret = -EINVAL;
diff --git a/block/blkverify.c b/block/blkverify.c
index 1684b7aa2e..5c3b29244a 100644
--- a/block/blkverify.c
+++ b/block/blkverify.c
@@ -125,7 +125,9 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags,
/* Open the raw file */
bs->file = bdrv_open_child(qemu_opt_get(opts, "x-raw"), options, "raw",
- bs, &child_file, 0, false, &local_err);
+ bs, &child_of_bds,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
+ false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
diff --git a/block/copy-on-read.c b/block/copy-on-read.c
index a2d92ac394..c857ea0da7 100644
--- a/block/copy-on-read.c
+++ b/block/copy-on-read.c
@@ -28,8 +28,9 @@
static int cor_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0, false,
- errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
+ false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/filter-compress.c b/block/filter-compress.c
index 4dc5f9fb8c..9edd937645 100644
--- a/block/filter-compress.c
+++ b/block/filter-compress.c
@@ -30,8 +30,9 @@
static int compress_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0, false,
- errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
+ false, errp);
if (!bs->file) {
return -EINVAL;
}
diff --git a/block/replication.c b/block/replication.c
index 9ca5c9368e..ec512ae1c3 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -90,7 +90,8 @@ static int replication_open(BlockDriverState *bs, QDict *options,
const char *mode;
const char *top_id;
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
false, errp);
if (!bs->file) {
return -EINVAL;
diff --git a/block/throttle.c b/block/throttle.c
index 2dea913be7..47b0a3522d 100644
--- a/block/throttle.c
+++ b/block/throttle.c
@@ -81,8 +81,9 @@ static int throttle_open(BlockDriverState *bs, QDict *options,
char *group;
int ret;
- bs->file = bdrv_open_child(NULL, options, "file", bs,
- &child_file, 0, false, errp);
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
+ false, errp);
if (!bs->file) {
return -EINVAL;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 26/33] block: Use child_of_bds in remaining places
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (24 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 25/33] block: Make filter " Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-05-06 17:04 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 27/33] tests: Use child_of_bds instead of child_file Max Reitz
` (6 subsequent siblings)
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Replace child_file by child_of_bds in all remaining places (excluding
tests).
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 3 ++-
block/backup-top.c | 4 ++--
block/blklogwrites.c | 4 ++--
block/blkreplay.c | 5 +++--
block/raw-format.c | 15 +++++++++++++--
5 files changed, 22 insertions(+), 9 deletions(-)
diff --git a/block.c b/block.c
index 1f573f3815..d3beed1819 100644
--- a/block.c
+++ b/block.c
@@ -3242,7 +3242,8 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
BlockDriverState *file_bs;
file_bs = bdrv_open_child_bs(filename, options, "file", bs,
- &child_file, 0, true, &local_err);
+ &child_of_bds, BDRV_CHILD_IMAGE,
+ true, &local_err);
if (local_err) {
goto fail;
}
diff --git a/block/backup-top.c b/block/backup-top.c
index c173e61250..3d6f6530a2 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -210,8 +210,8 @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
source->supported_zero_flags);
bdrv_ref(target);
- state->target = bdrv_attach_child(top, target, "target", &child_file, 0,
- errp);
+ state->target = bdrv_attach_child(top, target, "target", &child_of_bds,
+ BDRV_CHILD_DATA, errp);
if (!state->target) {
bdrv_unref(target);
bdrv_unref(top);
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index 78b0c49460..3a57b273fc 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -167,8 +167,8 @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
}
/* Open the log file */
- s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_file, 0,
- false, &local_err);
+ s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_of_bds,
+ BDRV_CHILD_METADATA, false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
diff --git a/block/blkreplay.c b/block/blkreplay.c
index f97493f45a..71628f4d56 100644
--- a/block/blkreplay.c
+++ b/block/blkreplay.c
@@ -27,8 +27,9 @@ static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
int ret;
/* Open the image file */
- bs->file = bdrv_open_child(NULL, options, "image",
- bs, &child_file, 0, false, &local_err);
+ bs->file = bdrv_open_child(NULL, options, "image", bs, &child_of_bds,
+ BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY,
+ false, &local_err);
if (local_err) {
ret = -EINVAL;
error_propagate(errp, local_err);
diff --git a/block/raw-format.c b/block/raw-format.c
index 33f5942474..c6470e4622 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -444,6 +444,7 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
BDRVRawState *s = bs->opaque;
bool has_size;
uint64_t offset, size;
+ BdrvChildRole file_role;
int ret;
ret = raw_read_options(options, &offset, &has_size, &size, errp);
@@ -451,8 +452,18 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
return ret;
}
- bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 0,
- false, errp);
+ /*
+ * Without offset and a size limit, this driver behaves very much
+ * like a filter. With any such limit, it does not.
+ */
+ if (offset || has_size) {
+ file_role = BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY;
+ } else {
+ file_role = BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
+ }
+
+ bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
+ file_role, false, errp);
if (!bs->file) {
return -EINVAL;
}
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 26/33] block: Use child_of_bds in remaining places
2020-02-18 12:42 ` [PATCH v3 26/33] block: Use child_of_bds in remaining places Max Reitz
@ 2020-05-06 17:04 ` Kevin Wolf
2020-05-07 9:33 ` Max Reitz
0 siblings, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 17:04 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> Replace child_file by child_of_bds in all remaining places (excluding
> tests).
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> Reviewed-by: Eric Blake <eblake@redhat.com>
> diff --git a/block/blkreplay.c b/block/blkreplay.c
> index f97493f45a..71628f4d56 100644
> --- a/block/blkreplay.c
> +++ b/block/blkreplay.c
> @@ -27,8 +27,9 @@ static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
> int ret;
>
> /* Open the image file */
> - bs->file = bdrv_open_child(NULL, options, "image",
> - bs, &child_file, 0, false, &local_err);
> + bs->file = bdrv_open_child(NULL, options, "image", bs, &child_of_bds,
> + BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY,
> + false, &local_err);
Why isn't blkreplay a filter?
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 26/33] block: Use child_of_bds in remaining places
2020-05-06 17:04 ` Kevin Wolf
@ 2020-05-07 9:33 ` Max Reitz
2020-05-07 11:32 ` Kevin Wolf
0 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-05-07 9:33 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 1367 bytes --]
On 06.05.20 19:04, Kevin Wolf wrote:
> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>> Replace child_file by child_of_bds in all remaining places (excluding
>> tests).
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> Reviewed-by: Eric Blake <eblake@redhat.com>
>
>> diff --git a/block/blkreplay.c b/block/blkreplay.c
>> index f97493f45a..71628f4d56 100644
>> --- a/block/blkreplay.c
>> +++ b/block/blkreplay.c
>> @@ -27,8 +27,9 @@ static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
>> int ret;
>>
>> /* Open the image file */
>> - bs->file = bdrv_open_child(NULL, options, "image",
>> - bs, &child_file, 0, false, &local_err);
>> + bs->file = bdrv_open_child(NULL, options, "image", bs, &child_of_bds,
>> + BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY,
>> + false, &local_err);
>
> Why isn't blkreplay a filter?
I don’t know, but that’s pre-existing. (It doesn’t set .is_filter.)
I’m afraid I have little insight into what blkreplay actually does. I
thought maybe in conjunction with the whole replay stuff it might turn
out not to be a filter.
So is it a filter? If so, no problem. I suppose we can fix it up in
the same patch that marks mirror-top and commit-top as filters.
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 26/33] block: Use child_of_bds in remaining places
2020-05-07 9:33 ` Max Reitz
@ 2020-05-07 11:32 ` Kevin Wolf
0 siblings, 0 replies; 63+ messages in thread
From: Kevin Wolf @ 2020-05-07 11:32 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
[-- Attachment #1: Type: text/plain, Size: 1702 bytes --]
Am 07.05.2020 um 11:33 hat Max Reitz geschrieben:
> On 06.05.20 19:04, Kevin Wolf wrote:
> > Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> >> Replace child_file by child_of_bds in all remaining places (excluding
> >> tests).
> >>
> >> Signed-off-by: Max Reitz <mreitz@redhat.com>
> >> Reviewed-by: Eric Blake <eblake@redhat.com>
> >
> >> diff --git a/block/blkreplay.c b/block/blkreplay.c
> >> index f97493f45a..71628f4d56 100644
> >> --- a/block/blkreplay.c
> >> +++ b/block/blkreplay.c
> >> @@ -27,8 +27,9 @@ static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
> >> int ret;
> >>
> >> /* Open the image file */
> >> - bs->file = bdrv_open_child(NULL, options, "image",
> >> - bs, &child_file, 0, false, &local_err);
> >> + bs->file = bdrv_open_child(NULL, options, "image", bs, &child_of_bds,
> >> + BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY,
> >> + false, &local_err);
> >
> > Why isn't blkreplay a filter?
> I don’t know, but that’s pre-existing. (It doesn’t set .is_filter.)
>
> I’m afraid I have little insight into what blkreplay actually does. I
> thought maybe in conjunction with the whole replay stuff it might turn
> out not to be a filter.
>
> So is it a filter? If so, no problem. I suppose we can fix it up in
> the same patch that marks mirror-top and commit-top as filters.
I think it is one. If I understand correctly, it basically just changes
the timing of requests, but nothing about their data.
Adding .is_filter to it in the same patch with mirror-top/commit-top
makes sense to me.
Kevin
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 27/33] tests: Use child_of_bds instead of child_file
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (25 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 26/33] block: Use child_of_bds in remaining places Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 28/33] block: Use bdrv_default_perms() Max Reitz
` (5 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
tests/test-bdrv-drain.c | 29 +++++++++++++++++------------
tests/test-bdrv-graph-mod.c | 6 ++++--
2 files changed, 21 insertions(+), 14 deletions(-)
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index 15393a0140..91567ca97d 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -97,7 +97,7 @@ static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
* detach_by_driver_cb_parent as one of them.
*/
if (child_class != &child_file && child_class != &child_of_bds) {
- child_class = &child_file;
+ child_class = &child_of_bds;
}
bdrv_format_default_perms(bs, c, child_class, role, reopen_queue,
@@ -1203,7 +1203,8 @@ static void do_test_delete_by_drain(bool detach_instead_of_delete,
null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
&error_abort);
- bdrv_attach_child(bs, null_bs, "null-child", &child_file, 0, &error_abort);
+ bdrv_attach_child(bs, null_bs, "null-child", &child_of_bds,
+ BDRV_CHILD_DATA, &error_abort);
/* This child will be the one to pass to requests through to, and
* it will stall until a drain occurs */
@@ -1211,14 +1212,17 @@ static void do_test_delete_by_drain(bool detach_instead_of_delete,
&error_abort);
child_bs->total_sectors = 65536 >> BDRV_SECTOR_BITS;
/* Takes our reference to child_bs */
- tts->wait_child = bdrv_attach_child(bs, child_bs, "wait-child", &child_file,
- 0, &error_abort);
+ tts->wait_child = bdrv_attach_child(bs, child_bs, "wait-child",
+ &child_of_bds,
+ BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY,
+ &error_abort);
/* This child is just there to be deleted
* (for detach_instead_of_delete == true) */
null_bs = bdrv_open("null-co://", NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
&error_abort);
- bdrv_attach_child(bs, null_bs, "null-child", &child_file, 0, &error_abort);
+ bdrv_attach_child(bs, null_bs, "null-child", &child_of_bds, BDRV_CHILD_DATA,
+ &error_abort);
blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
blk_insert_bs(blk, bs, &error_abort);
@@ -1315,7 +1319,8 @@ static void detach_indirect_bh(void *opaque)
bdrv_ref(data->c);
data->child_c = bdrv_attach_child(data->parent_b, data->c, "PB-C",
- &child_file, 0, &error_abort);
+ &child_of_bds, BDRV_CHILD_DATA,
+ &error_abort);
}
static void detach_by_parent_aio_cb(void *opaque, int ret)
@@ -1332,7 +1337,7 @@ static void detach_by_driver_cb_drained_begin(BdrvChild *child)
{
aio_bh_schedule_oneshot(qemu_get_current_aio_context(),
detach_indirect_bh, &detach_by_parent_data);
- child_file.drained_begin(child);
+ child_of_bds.drained_begin(child);
}
static BdrvChildClass detach_by_driver_cb_class;
@@ -1367,7 +1372,7 @@ static void test_detach_indirect(bool by_parent_cb)
QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
if (!by_parent_cb) {
- detach_by_driver_cb_class = child_file;
+ detach_by_driver_cb_class = child_of_bds;
detach_by_driver_cb_class.drained_begin =
detach_by_driver_cb_drained_begin;
}
@@ -1397,15 +1402,15 @@ static void test_detach_indirect(bool by_parent_cb)
/* Set child relationships */
bdrv_ref(b);
bdrv_ref(a);
- child_b = bdrv_attach_child(parent_b, b, "PB-B", &child_file, 0,
- &error_abort);
+ child_b = bdrv_attach_child(parent_b, b, "PB-B", &child_of_bds,
+ BDRV_CHILD_DATA, &error_abort);
child_a = bdrv_attach_child(parent_b, a, "PB-A", &child_of_bds,
BDRV_CHILD_COW, &error_abort);
bdrv_ref(a);
bdrv_attach_child(parent_a, a, "PA-A",
- by_parent_cb ? &child_file : &detach_by_driver_cb_class,
- 0, &error_abort);
+ by_parent_cb ? &child_of_bds : &detach_by_driver_cb_class,
+ BDRV_CHILD_DATA, &error_abort);
g_assert_cmpint(parent_a->refcnt, ==, 1);
g_assert_cmpint(parent_b->refcnt, ==, 1);
diff --git a/tests/test-bdrv-graph-mod.c b/tests/test-bdrv-graph-mod.c
index 3707e2533c..6ae91ff171 100644
--- a/tests/test-bdrv-graph-mod.c
+++ b/tests/test-bdrv-graph-mod.c
@@ -112,7 +112,8 @@ static void test_update_perm_tree(void)
blk_insert_bs(root, bs, &error_abort);
- bdrv_attach_child(filter, bs, "child", &child_file, 0, &error_abort);
+ bdrv_attach_child(filter, bs, "child", &child_of_bds,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, &error_abort);
bdrv_append(filter, bs, &local_err);
@@ -178,7 +179,8 @@ static void test_should_update_child(void)
bdrv_set_backing_hd(target, bs, &error_abort);
g_assert(target->backing->bs == bs);
- bdrv_attach_child(filter, target, "target", &child_file, 0, &error_abort);
+ bdrv_attach_child(filter, target, "target", &child_of_bds,
+ BDRV_CHILD_DATA, &error_abort);
bdrv_append(filter, bs, &error_abort);
g_assert(target->backing->bs == bs);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 28/33] block: Use bdrv_default_perms()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (26 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 27/33] tests: Use child_of_bds instead of child_file Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 29/33] block: Make bdrv_filter_default_perms() static Max Reitz
` (4 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
bdrv_default_perms() can decide which permission profile to use based on
the BdrvChildRole, so block drivers do not need to select it explicitly.
The blkverify driver now no longer shares the WRITE permission for the
image to verify. We thus have to adjust two places in
test-block-iothread not to take it. (Note that in theory, blkverify
should behave like quorum in this regard and share neither WRITE nor
RESIZE for both of its children. In practice, it does not really
matter, because blkverify is used only for debugging, so we might as
well keep its permissions rather liberal.)
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block/backup-top.c | 4 ++--
block/blkdebug.c | 4 ++--
block/blklogwrites.c | 9 ++-------
block/blkreplay.c | 2 +-
block/blkverify.c | 2 +-
block/bochs.c | 2 +-
block/cloop.c | 2 +-
block/crypto.c | 2 +-
block/dmg.c | 2 +-
block/filter-compress.c | 2 +-
block/parallels.c | 2 +-
block/qcow.c | 2 +-
block/qcow2.c | 2 +-
block/qed.c | 2 +-
block/raw-format.c | 2 +-
block/throttle.c | 2 +-
block/vdi.c | 2 +-
block/vhdx.c | 2 +-
block/vmdk.c | 2 +-
block/vpc.c | 2 +-
tests/test-bdrv-drain.c | 10 +++++-----
tests/test-bdrv-graph-mod.c | 2 +-
tests/test-block-iothread.c | 17 ++++++++++++++---
23 files changed, 43 insertions(+), 37 deletions(-)
diff --git a/block/backup-top.c b/block/backup-top.c
index 3d6f6530a2..00dbad44b5 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -153,8 +153,8 @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
*nperm = BLK_PERM_WRITE;
} else {
/* Source child */
- bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
+ bdrv_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
if (perm & BLK_PERM_WRITE) {
*nperm = *nperm | BLK_PERM_CONSISTENT_READ;
diff --git a/block/blkdebug.c b/block/blkdebug.c
index b31fa40b0e..a925d8295e 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -1003,8 +1003,8 @@ static void blkdebug_child_perm(BlockDriverState *bs, BdrvChild *c,
{
BDRVBlkdebugState *s = bs->opaque;
- bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
+ bdrv_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
*nperm |= s->take_child_perms;
*nshared &= ~s->unshare_child_perms;
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index 3a57b273fc..8684fb1c74 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -295,13 +295,8 @@ static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
return;
}
- if (!strcmp(c->name, "log")) {
- bdrv_format_default_perms(bs, c, child_class, role, ro_q, perm, shrd,
- nperm, nshrd);
- } else {
- bdrv_filter_default_perms(bs, c, child_class, role, ro_q, perm, shrd,
- nperm, nshrd);
- }
+ bdrv_default_perms(bs, c, child_class, role, ro_q, perm, shrd,
+ nperm, nshrd);
}
static void blk_log_writes_refresh_limits(BlockDriverState *bs, Error **errp)
diff --git a/block/blkreplay.c b/block/blkreplay.c
index 71628f4d56..be8cdb6b60 100644
--- a/block/blkreplay.c
+++ b/block/blkreplay.c
@@ -138,7 +138,7 @@ static BlockDriver bdrv_blkreplay = {
.instance_size = 0,
.bdrv_open = blkreplay_open,
- .bdrv_child_perm = bdrv_filter_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_getlength = blkreplay_getlength,
.bdrv_co_preadv = blkreplay_co_preadv,
diff --git a/block/blkverify.c b/block/blkverify.c
index 5c3b29244a..2f261de24b 100644
--- a/block/blkverify.c
+++ b/block/blkverify.c
@@ -319,7 +319,7 @@ static BlockDriver bdrv_blkverify = {
.bdrv_parse_filename = blkverify_parse_filename,
.bdrv_file_open = blkverify_open,
.bdrv_close = blkverify_close,
- .bdrv_child_perm = bdrv_filter_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_getlength = blkverify_getlength,
.bdrv_refresh_filename = blkverify_refresh_filename,
.bdrv_dirname = blkverify_dirname,
diff --git a/block/bochs.c b/block/bochs.c
index 62c3f42548..2f010ab40a 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -297,7 +297,7 @@ static BlockDriver bdrv_bochs = {
.instance_size = sizeof(BDRVBochsState),
.bdrv_probe = bochs_probe,
.bdrv_open = bochs_open,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_refresh_limits = bochs_refresh_limits,
.bdrv_co_preadv = bochs_co_preadv,
.bdrv_close = bochs_close,
diff --git a/block/cloop.c b/block/cloop.c
index d374a8427d..c99192a57f 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -293,7 +293,7 @@ static BlockDriver bdrv_cloop = {
.instance_size = sizeof(BDRVCloopState),
.bdrv_probe = cloop_probe,
.bdrv_open = cloop_open,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_refresh_limits = cloop_refresh_limits,
.bdrv_co_preadv = cloop_co_preadv,
.bdrv_close = cloop_close,
diff --git a/block/crypto.c b/block/crypto.c
index 2d85d9e70a..474f44b5db 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -659,7 +659,7 @@ static BlockDriver bdrv_crypto_luks = {
.bdrv_close = block_crypto_close,
/* This driver doesn't modify LUKS metadata except when creating image.
* Allow share-rw=on as a special case. */
- .bdrv_child_perm = bdrv_filter_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_create = block_crypto_co_create_luks,
.bdrv_co_create_opts = block_crypto_co_create_opts_luks,
.bdrv_co_truncate = block_crypto_co_truncate,
diff --git a/block/dmg.c b/block/dmg.c
index bc64194577..0d6c317296 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -750,7 +750,7 @@ static BlockDriver bdrv_dmg = {
.bdrv_probe = dmg_probe,
.bdrv_open = dmg_open,
.bdrv_refresh_limits = dmg_refresh_limits,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_preadv = dmg_co_preadv,
.bdrv_close = dmg_close,
.is_format = true,
diff --git a/block/filter-compress.c b/block/filter-compress.c
index 9edd937645..8ec1991c1f 100644
--- a/block/filter-compress.c
+++ b/block/filter-compress.c
@@ -133,7 +133,7 @@ static BlockDriver bdrv_compress = {
.format_name = "compress",
.bdrv_open = compress_open,
- .bdrv_child_perm = bdrv_filter_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_getlength = compress_getlength,
diff --git a/block/parallels.c b/block/parallels.c
index 7dc9a1fa76..452d6dbfab 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -904,7 +904,7 @@ static BlockDriver bdrv_parallels = {
.bdrv_probe = parallels_probe,
.bdrv_open = parallels_open,
.bdrv_close = parallels_close,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_block_status = parallels_co_block_status,
.bdrv_has_zero_init = bdrv_has_zero_init_1,
.bdrv_co_flush_to_os = parallels_co_flush_to_os,
diff --git a/block/qcow.c b/block/qcow.c
index bc7f7c1054..f4219d9d56 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -1179,7 +1179,7 @@ static BlockDriver bdrv_qcow = {
.bdrv_probe = qcow_probe,
.bdrv_open = qcow_open,
.bdrv_close = qcow_close,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_reopen_prepare = qcow_reopen_prepare,
.bdrv_co_create = qcow_co_create,
.bdrv_co_create_opts = qcow_co_create_opts,
diff --git a/block/qcow2.c b/block/qcow2.c
index 7e1532cc5e..cdcd544837 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -5543,7 +5543,7 @@ BlockDriver bdrv_qcow2 = {
.bdrv_reopen_commit = qcow2_reopen_commit,
.bdrv_reopen_abort = qcow2_reopen_abort,
.bdrv_join_options = qcow2_join_options,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_create_opts = qcow2_co_create_opts,
.bdrv_co_create = qcow2_co_create,
.bdrv_has_zero_init = qcow2_has_zero_init,
diff --git a/block/qed.c b/block/qed.c
index d6222798c2..08c63f1378 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -1670,7 +1670,7 @@ static BlockDriver bdrv_qed = {
.bdrv_open = bdrv_qed_open,
.bdrv_close = bdrv_qed_close,
.bdrv_reopen_prepare = bdrv_qed_reopen_prepare,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_create = bdrv_qed_co_create,
.bdrv_co_create_opts = bdrv_qed_co_create_opts,
.bdrv_has_zero_init = bdrv_has_zero_init_1,
diff --git a/block/raw-format.c b/block/raw-format.c
index c6470e4622..87a6e3303d 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -587,7 +587,7 @@ BlockDriver bdrv_raw = {
.bdrv_reopen_commit = &raw_reopen_commit,
.bdrv_reopen_abort = &raw_reopen_abort,
.bdrv_open = &raw_open,
- .bdrv_child_perm = bdrv_filter_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_create_opts = &raw_co_create_opts,
.bdrv_co_preadv = &raw_co_preadv,
.bdrv_co_pwritev = &raw_co_pwritev,
diff --git a/block/throttle.c b/block/throttle.c
index 47b0a3522d..0ebbad0743 100644
--- a/block/throttle.c
+++ b/block/throttle.c
@@ -237,7 +237,7 @@ static BlockDriver bdrv_throttle = {
.bdrv_close = throttle_close,
.bdrv_co_flush = throttle_co_flush,
- .bdrv_child_perm = bdrv_filter_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_getlength = throttle_getlength,
diff --git a/block/vdi.c b/block/vdi.c
index 1736d02eee..4df7f0fc60 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -1037,7 +1037,7 @@ static BlockDriver bdrv_vdi = {
.bdrv_open = vdi_open,
.bdrv_close = vdi_close,
.bdrv_reopen_prepare = vdi_reopen_prepare,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_create = vdi_co_create,
.bdrv_co_create_opts = vdi_co_create_opts,
.bdrv_has_zero_init = vdi_has_zero_init,
diff --git a/block/vhdx.c b/block/vhdx.c
index d8a315015d..18c1f2768a 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -2232,7 +2232,7 @@ static BlockDriver bdrv_vhdx = {
.bdrv_open = vhdx_open,
.bdrv_close = vhdx_close,
.bdrv_reopen_prepare = vhdx_reopen_prepare,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_readv = vhdx_co_readv,
.bdrv_co_writev = vhdx_co_writev,
.bdrv_co_create = vhdx_co_create,
diff --git a/block/vmdk.c b/block/vmdk.c
index 497414e5f2..79f6666a11 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -3055,7 +3055,7 @@ static BlockDriver bdrv_vmdk = {
.bdrv_open = vmdk_open,
.bdrv_co_check = vmdk_co_check,
.bdrv_reopen_prepare = vmdk_reopen_prepare,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_preadv = vmdk_co_preadv,
.bdrv_co_pwritev = vmdk_co_pwritev,
.bdrv_co_pwritev_compressed = vmdk_co_pwritev_compressed,
diff --git a/block/vpc.c b/block/vpc.c
index 9acd6edac9..955c58aa2b 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -1238,7 +1238,7 @@ static BlockDriver bdrv_vpc = {
.bdrv_open = vpc_open,
.bdrv_close = vpc_close,
.bdrv_reopen_prepare = vpc_reopen_prepare,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_co_create = vpc_co_create,
.bdrv_co_create_opts = vpc_co_create_opts,
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index 91567ca97d..0da5a3a6a1 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -93,15 +93,15 @@ static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
uint64_t *nperm, uint64_t *nshared)
{
/*
- * bdrv_format_default_perms() accepts only these two, so disguise
+ * bdrv_default_perms() accepts only these two, so disguise
* detach_by_driver_cb_parent as one of them.
*/
if (child_class != &child_file && child_class != &child_of_bds) {
child_class = &child_of_bds;
}
- bdrv_format_default_perms(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
+ bdrv_default_perms(bs, c, child_class, role, reopen_queue,
+ perm, shared, nperm, nshared);
}
static int bdrv_test_change_backing_file(BlockDriverState *bs,
@@ -1137,7 +1137,7 @@ static BlockDriver bdrv_test_top_driver = {
.bdrv_close = bdrv_test_top_close,
.bdrv_co_preadv = bdrv_test_top_co_preadv,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
};
typedef struct TestCoDeleteByDrainData {
@@ -1966,7 +1966,7 @@ static BlockDriver bdrv_replace_test = {
.bdrv_co_drain_begin = bdrv_replace_test_co_drain_begin,
.bdrv_co_drain_end = bdrv_replace_test_co_drain_end,
- .bdrv_child_perm = bdrv_format_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
};
static void coroutine_fn test_replace_child_mid_drain_read_co(void *opaque)
diff --git a/tests/test-bdrv-graph-mod.c b/tests/test-bdrv-graph-mod.c
index 6ae91ff171..a2d0318b16 100644
--- a/tests/test-bdrv-graph-mod.c
+++ b/tests/test-bdrv-graph-mod.c
@@ -26,7 +26,7 @@
static BlockDriver bdrv_pass_through = {
.format_name = "pass-through",
- .bdrv_child_perm = bdrv_filter_default_perms,
+ .bdrv_child_perm = bdrv_default_perms,
};
static void no_perm_default_perms(BlockDriverState *bs, BdrvChild *c,
diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
index 0c861809f0..d928d2c6d9 100644
--- a/tests/test-block-iothread.c
+++ b/tests/test-block-iothread.c
@@ -481,8 +481,13 @@ static void test_propagate_basic(void)
BlockDriverState *bs_a, *bs_b, *bs_verify;
QDict *options;
- /* Create bs_a and its BlockBackend */
- blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
+ /*
+ * Create bs_a and its BlockBackend. We cannot take the RESIZE
+ * permission because blkverify will not share it on the test
+ * image.
+ */
+ blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
+ BLK_PERM_ALL);
bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);
blk_insert_bs(blk, bs_a, &error_abort);
@@ -565,7 +570,13 @@ static void test_propagate_diamond(void)
qdict_put_str(options, "raw", "bs_c");
bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
- blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
+ /*
+ * Do not take the RESIZE permission: This would require the same
+ * from bs_c and thus from bs_a; however, blkverify will not share
+ * it on bs_b, and thus it will not be available for bs_a.
+ */
+ blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
+ BLK_PERM_ALL);
blk_insert_bs(blk, bs_verify, &error_abort);
/* Switch the AioContext */
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 29/33] block: Make bdrv_filter_default_perms() static
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (27 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 28/33] block: Use bdrv_default_perms() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 30/33] block: Drop bdrv_format_default_perms() Max Reitz
` (3 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 17 +++++++++++------
include/block/block_int.h | 10 ----------
2 files changed, 11 insertions(+), 16 deletions(-)
diff --git a/block.c b/block.c
index d3beed1819..a7c2ad6c5b 100644
--- a/block.c
+++ b/block.c
@@ -2216,12 +2216,17 @@ int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
return bdrv_child_try_set_perm(c, perms, shared, errp);
}
-void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
- BdrvChildRole role,
- BlockReopenQueue *reopen_queue,
- uint64_t perm, uint64_t shared,
- uint64_t *nperm, uint64_t *nshared)
+/*
+ * Default implementation for .bdrv_child_perm() for block filters:
+ * Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED, and RESIZE to the
+ * filtered child.
+ */
+static void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
+ const BdrvChildClass *child_class,
+ BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
+ uint64_t perm, uint64_t shared,
+ uint64_t *nperm, uint64_t *nshared)
{
*nperm = perm & DEFAULT_PERM_PASSTHROUGH;
*nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
diff --git a/include/block/block_int.h b/include/block/block_int.h
index ab64a5ccea..c2fb6b8899 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -1253,16 +1253,6 @@ int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
*/
int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp);
-/* Default implementation for BlockDriver.bdrv_child_perm() that can be used by
- * block filters: Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED and RESIZE to
- * all children */
-void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
- BdrvChildRole child_role,
- BlockReopenQueue *reopen_queue,
- uint64_t perm, uint64_t shared,
- uint64_t *nperm, uint64_t *nshared);
-
/* Default implementation for BlockDriver.bdrv_child_perm() that can be used by
* (non-raw) image formats: Like above for bs->backing, but for bs->file it
* requires WRITE | RESIZE for read-write images, always requires
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 30/33] block: Drop bdrv_format_default_perms()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (28 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 29/33] block: Make bdrv_filter_default_perms() static Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 31/33] block: Drop child_file Max Reitz
` (2 subsequent siblings)
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 19 -------------------
include/block/block_int.h | 11 -----------
2 files changed, 30 deletions(-)
diff --git a/block.c b/block.c
index a7c2ad6c5b..16eb790ea6 100644
--- a/block.c
+++ b/block.c
@@ -2344,25 +2344,6 @@ static void bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
*nshared = shared;
}
-void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
- BdrvChildRole role,
- BlockReopenQueue *reopen_queue,
- uint64_t perm, uint64_t shared,
- uint64_t *nperm, uint64_t *nshared)
-{
- if (child_class == &child_of_bds) {
- bdrv_default_perms(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
- return;
- }
-
- assert(child_class == &child_file);
-
- bdrv_default_perms_for_metadata(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
-}
-
void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
const BdrvChildClass *child_class, BdrvChildRole role,
BlockReopenQueue *reopen_queue,
diff --git a/include/block/block_int.h b/include/block/block_int.h
index c2fb6b8899..28a35cd5d1 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -1253,17 +1253,6 @@ int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
*/
int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp);
-/* Default implementation for BlockDriver.bdrv_child_perm() that can be used by
- * (non-raw) image formats: Like above for bs->backing, but for bs->file it
- * requires WRITE | RESIZE for read-write images, always requires
- * CONSISTENT_READ and doesn't share WRITE. */
-void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
- BdrvChildRole child_role,
- BlockReopenQueue *reopen_queue,
- uint64_t perm, uint64_t shared,
- uint64_t *nperm, uint64_t *nshared);
-
bool bdrv_recurse_can_replace(BlockDriverState *bs,
BlockDriverState *to_replace);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 31/33] block: Drop child_file
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (29 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 30/33] block: Drop bdrv_format_default_perms() Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-02-18 12:42 ` [PATCH v3 32/33] block: Pass BdrvChildRole in remaining cases Max Reitz
2020-02-18 12:42 ` [PATCH v3 33/33] block: Drop @child_class from bdrv_child_perm() Max Reitz
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 30 +-----------------------------
include/block/block_int.h | 1 -
tests/test-bdrv-drain.c | 8 +++-----
3 files changed, 4 insertions(+), 35 deletions(-)
diff --git a/block.c b/block.c
index 16eb790ea6..986f99415c 100644
--- a/block.c
+++ b/block.c
@@ -1121,33 +1121,6 @@ const BdrvChildClass child_of_bds = {
.update_filename = bdrv_child_cb_update_filename,
};
-/*
- * Returns the options and flags that bs->file should get if a protocol driver
- * is expected, based on the given options and flags for the parent BDS
- */
-static void bdrv_protocol_options(BdrvChildRole role, bool parent_is_format,
- int *child_flags, QDict *child_options,
- int parent_flags, QDict *parent_options)
-{
- bdrv_inherited_options(BDRV_CHILD_IMAGE, true,
- child_flags, child_options,
- parent_flags, parent_options);
-}
-
-const BdrvChildClass child_file = {
- .parent_is_bds = true,
- .get_parent_desc = bdrv_child_get_parent_desc,
- .inherit_options = bdrv_protocol_options,
- .drained_begin = bdrv_child_cb_drained_begin,
- .drained_poll = bdrv_child_cb_drained_poll,
- .drained_end = bdrv_child_cb_drained_end,
- .attach = bdrv_child_cb_attach,
- .detach = bdrv_child_cb_detach,
- .inactivate = bdrv_child_cb_inactivate,
- .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx,
- .set_aio_ctx = bdrv_child_cb_set_aio_ctx,
-};
-
static void bdrv_backing_attach(BdrvChild *c)
{
BlockDriverState *parent = c->opaque;
@@ -2278,8 +2251,7 @@ static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
{
int flags;
- assert(child_class == &child_file ||
- (child_class == &child_of_bds && (role & BDRV_CHILD_METADATA)));
+ assert(child_class == &child_of_bds && (role & BDRV_CHILD_METADATA));
flags = bdrv_reopen_get_flags(reopen_queue, bs);
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 28a35cd5d1..1609e40b58 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -741,7 +741,6 @@ struct BdrvChildClass {
};
extern const BdrvChildClass child_of_bds;
-extern const BdrvChildClass child_file;
struct BdrvChild {
BlockDriverState *bs;
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index 0da5a3a6a1..655fd0d085 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -93,12 +93,10 @@ static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
uint64_t *nperm, uint64_t *nshared)
{
/*
- * bdrv_default_perms() accepts only these two, so disguise
- * detach_by_driver_cb_parent as one of them.
+ * bdrv_default_perms() accepts nothing else, so disguise
+ * detach_by_driver_cb_parent.
*/
- if (child_class != &child_file && child_class != &child_of_bds) {
- child_class = &child_of_bds;
- }
+ child_class = &child_of_bds;
bdrv_default_perms(bs, c, child_class, role, reopen_queue,
perm, shared, nperm, nshared);
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* [PATCH v3 32/33] block: Pass BdrvChildRole in remaining cases
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (30 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 31/33] block: Drop child_file Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
2020-05-06 17:13 ` Kevin Wolf
2020-02-18 12:42 ` [PATCH v3 33/33] block: Drop @child_class from bdrv_child_perm() Max Reitz
32 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
These calls have no real use for the child role yet, but it will not
harm to give one.
Notably, the bdrv_root_attach_child() call in blockjob.c is left
unmodified because there is not much the generic BlockJob object wants
from its children.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block/block-backend.c | 11 +++++++----
block/vvfat.c | 2 +-
2 files changed, 8 insertions(+), 5 deletions(-)
diff --git a/block/block-backend.c b/block/block-backend.c
index 9e0078bfb5..e655e15675 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -401,8 +401,9 @@ BlockBackend *blk_new_open(const char *filename, const char *reference,
return NULL;
}
- blk->root = bdrv_root_attach_child(bs, "root", &child_root, 0, blk->ctx,
- perm, BLK_PERM_ALL, blk, errp);
+ blk->root = bdrv_root_attach_child(bs, "root", &child_root,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
+ blk->ctx, perm, BLK_PERM_ALL, blk, errp);
if (!blk->root) {
blk_unref(blk);
return NULL;
@@ -812,8 +813,10 @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
{
ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
bdrv_ref(bs);
- blk->root = bdrv_root_attach_child(bs, "root", &child_root, 0, blk->ctx,
- blk->perm, blk->shared_perm, blk, errp);
+ blk->root = bdrv_root_attach_child(bs, "root", &child_root,
+ BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
+ blk->ctx, blk->perm, blk->shared_perm,
+ blk, errp);
if (blk->root == NULL) {
return -EPERM;
}
diff --git a/block/vvfat.c b/block/vvfat.c
index 8f4ff5a97e..d4f4218924 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3186,7 +3186,7 @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
options = qdict_new();
qdict_put_str(options, "write-target.driver", "qcow");
s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
- &child_vvfat_qcow, 0, false, errp);
+ &child_vvfat_qcow, BDRV_CHILD_DATA, false, errp);
qobject_unref(options);
if (!s->qcow) {
ret = -EINVAL;
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread* Re: [PATCH v3 32/33] block: Pass BdrvChildRole in remaining cases
2020-02-18 12:42 ` [PATCH v3 32/33] block: Pass BdrvChildRole in remaining cases Max Reitz
@ 2020-05-06 17:13 ` Kevin Wolf
2020-05-07 9:36 ` Max Reitz
0 siblings, 1 reply; 63+ messages in thread
From: Kevin Wolf @ 2020-05-06 17:13 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> These calls have no real use for the child role yet, but it will not
> harm to give one.
>
> Notably, the bdrv_root_attach_child() call in blockjob.c is left
> unmodified because there is not much the generic BlockJob object wants
> from its children.
>
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> Reviewed-by: Eric Blake <eblake@redhat.com>
> diff --git a/block/vvfat.c b/block/vvfat.c
> index 8f4ff5a97e..d4f4218924 100644
> --- a/block/vvfat.c
> +++ b/block/vvfat.c
> @@ -3186,7 +3186,7 @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
> options = qdict_new();
> qdict_put_str(options, "write-target.driver", "qcow");
> s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
> - &child_vvfat_qcow, 0, false, errp);
> + &child_vvfat_qcow, BDRV_CHILD_DATA, false, errp);
Doesn't it contain metadata, too?
Kevin
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 32/33] block: Pass BdrvChildRole in remaining cases
2020-05-06 17:13 ` Kevin Wolf
@ 2020-05-07 9:36 ` Max Reitz
2020-05-07 11:40 ` Kevin Wolf
0 siblings, 1 reply; 63+ messages in thread
From: Max Reitz @ 2020-05-07 9:36 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel, qemu-block
[-- Attachment #1.1: Type: text/plain, Size: 1401 bytes --]
On 06.05.20 19:13, Kevin Wolf wrote:
> Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
>> These calls have no real use for the child role yet, but it will not
>> harm to give one.
>>
>> Notably, the bdrv_root_attach_child() call in blockjob.c is left
>> unmodified because there is not much the generic BlockJob object wants
>> from its children.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> Reviewed-by: Eric Blake <eblake@redhat.com>
>
>> diff --git a/block/vvfat.c b/block/vvfat.c
>> index 8f4ff5a97e..d4f4218924 100644
>> --- a/block/vvfat.c
>> +++ b/block/vvfat.c
>> @@ -3186,7 +3186,7 @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
>> options = qdict_new();
>> qdict_put_str(options, "write-target.driver", "qcow");
>> s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
>> - &child_vvfat_qcow, 0, false, errp);
>> + &child_vvfat_qcow, BDRV_CHILD_DATA, false, errp);
>
> Doesn't it contain metadata, too?
Aw, I don’t know... This is vvfat, I don’t want to know.
Do you mean metadata beyond the filesystem structures? Are those
structures data or metadata in this context? Does it even matter?
I suppose I just don’t want to think about all of that, and the simplest
way to do it is to indeed pass METADATA, too.
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* Re: [PATCH v3 32/33] block: Pass BdrvChildRole in remaining cases
2020-05-07 9:36 ` Max Reitz
@ 2020-05-07 11:40 ` Kevin Wolf
0 siblings, 0 replies; 63+ messages in thread
From: Kevin Wolf @ 2020-05-07 11:40 UTC (permalink / raw)
To: Max Reitz; +Cc: qemu-devel, qemu-block
[-- Attachment #1: Type: text/plain, Size: 1837 bytes --]
Am 07.05.2020 um 11:36 hat Max Reitz geschrieben:
> On 06.05.20 19:13, Kevin Wolf wrote:
> > Am 18.02.2020 um 13:42 hat Max Reitz geschrieben:
> >> These calls have no real use for the child role yet, but it will not
> >> harm to give one.
> >>
> >> Notably, the bdrv_root_attach_child() call in blockjob.c is left
> >> unmodified because there is not much the generic BlockJob object wants
> >> from its children.
> >>
> >> Signed-off-by: Max Reitz <mreitz@redhat.com>
> >> Reviewed-by: Eric Blake <eblake@redhat.com>
> >
> >> diff --git a/block/vvfat.c b/block/vvfat.c
> >> index 8f4ff5a97e..d4f4218924 100644
> >> --- a/block/vvfat.c
> >> +++ b/block/vvfat.c
> >> @@ -3186,7 +3186,7 @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
> >> options = qdict_new();
> >> qdict_put_str(options, "write-target.driver", "qcow");
> >> s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
> >> - &child_vvfat_qcow, 0, false, errp);
> >> + &child_vvfat_qcow, BDRV_CHILD_DATA, false, errp);
> >
> > Doesn't it contain metadata, too?
>
> Aw, I don’t know... This is vvfat, I don’t want to know.
>
> Do you mean metadata beyond the filesystem structures? Are those
> structures data or metadata in this context? Does it even matter?
I can't say I understand what the qcow node is even used for in detail.
vvfat checks the allocation status in the qcow node in a few places,
does this count as metadata?
> I suppose I just don’t want to think about all of that, and the simplest
> way to do it is to indeed pass METADATA, too.
Yep, that was my thinking. If we can't decide whether it's just DATA or
also METADATA and want to err on the safe side, setting both should do.
Kevin
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply [flat|nested] 63+ messages in thread
* [PATCH v3 33/33] block: Drop @child_class from bdrv_child_perm()
2020-02-18 12:42 [PATCH v3 00/33] block: Introduce real BdrvChildRole Max Reitz
` (31 preceding siblings ...)
2020-02-18 12:42 ` [PATCH v3 32/33] block: Pass BdrvChildRole in remaining cases Max Reitz
@ 2020-02-18 12:42 ` Max Reitz
32 siblings, 0 replies; 63+ messages in thread
From: Max Reitz @ 2020-02-18 12:42 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, qemu-devel, Max Reitz
Implementations should decide the necessary permissions based on @role.
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
block.c | 45 ++++++++++++++++---------------------
block/backup-top.c | 3 +--
block/blkdebug.c | 3 +--
block/blklogwrites.c | 3 +--
block/commit.c | 1 -
block/copy-on-read.c | 1 -
block/mirror.c | 1 -
block/quorum.c | 1 -
block/replication.c | 1 -
block/vvfat.c | 4 +---
include/block/block_int.h | 4 +---
tests/test-bdrv-drain.c | 19 +---------------
tests/test-bdrv-graph-mod.c | 1 -
13 files changed, 25 insertions(+), 62 deletions(-)
diff --git a/block.c b/block.c
index 986f99415c..00c491dd91 100644
--- a/block.c
+++ b/block.c
@@ -1788,13 +1788,13 @@ bool bdrv_is_writable(BlockDriverState *bs)
}
static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
- BdrvChild *c, const BdrvChildClass *child_class,
- BdrvChildRole role, BlockReopenQueue *reopen_queue,
+ BdrvChild *c, BdrvChildRole role,
+ BlockReopenQueue *reopen_queue,
uint64_t parent_perm, uint64_t parent_shared,
uint64_t *nperm, uint64_t *nshared)
{
assert(bs->drv && bs->drv->bdrv_child_perm);
- bs->drv->bdrv_child_perm(bs, c, child_class, role, reopen_queue,
+ bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
parent_perm, parent_shared,
nperm, nshared);
/* TODO Take force_share from reopen_queue */
@@ -1888,7 +1888,7 @@ static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q,
uint64_t cur_perm, cur_shared;
bool child_tighten_restr;
- bdrv_child_perm(bs, c->bs, c, c->klass, c->role, q,
+ bdrv_child_perm(bs, c->bs, c, c->role, q,
cumulative_perms, cumulative_shared_perms,
&cur_perm, &cur_shared);
ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared, ignore_children,
@@ -1955,7 +1955,7 @@ static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
/* Update all children */
QLIST_FOREACH(c, &bs->children, next) {
uint64_t cur_perm, cur_shared;
- bdrv_child_perm(bs, c->bs, c, c->klass, c->role, NULL,
+ bdrv_child_perm(bs, c->bs, c, c->role, NULL,
cumulative_perms, cumulative_shared_perms,
&cur_perm, &cur_shared);
bdrv_child_set_perm(c, cur_perm, cur_shared);
@@ -2183,7 +2183,7 @@ int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
uint64_t perms, shared;
bdrv_get_cumulative_perm(bs, &parent_perms, &parent_shared);
- bdrv_child_perm(bs, c->bs, c, c->klass, c->role, NULL,
+ bdrv_child_perm(bs, c->bs, c, c->role, NULL,
parent_perms, parent_shared, &perms, &shared);
return bdrv_child_try_set_perm(c, perms, shared, errp);
@@ -2195,7 +2195,6 @@ int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
* filtered child.
*/
static void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
@@ -2206,13 +2205,12 @@ static void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
}
static void bdrv_default_perms_for_backing(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
- assert(child_class == &child_of_bds && (role & BDRV_CHILD_COW));
+ assert(role & BDRV_CHILD_COW);
/*
* We want consistent read from backing files if the parent needs it.
@@ -2243,7 +2241,6 @@ static void bdrv_default_perms_for_backing(BlockDriverState *bs, BdrvChild *c,
}
static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
@@ -2251,7 +2248,7 @@ static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
{
int flags;
- assert(child_class == &child_of_bds && (role & BDRV_CHILD_METADATA));
+ assert(role & BDRV_CHILD_METADATA);
flags = bdrv_reopen_get_flags(reopen_queue, bs);
@@ -2259,7 +2256,7 @@ static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
* Apart from the modifications below, the same permissions are
* forwarded and left alone as for filters
*/
- bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
+ bdrv_filter_default_perms(bs, c, role, reopen_queue,
perm, shared, &perm, &shared);
/* Format drivers may touch metadata even if the guest doesn't write */
@@ -2285,19 +2282,18 @@ static void bdrv_default_perms_for_metadata(BlockDriverState *bs, BdrvChild *c,
}
static void bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
- assert(child_class == &child_of_bds && (role & BDRV_CHILD_DATA));
+ assert(role & BDRV_CHILD_DATA);
/*
* Apart from the modifications below, the same permissions are
* forwarded and left alone as for filters
*/
- bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
+ bdrv_filter_default_perms(bs, c, role, reopen_queue,
perm, shared, &perm, &shared);
/*
@@ -2317,24 +2313,21 @@ static void bdrv_default_perms_for_data(BlockDriverState *bs, BdrvChild *c,
}
void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class, BdrvChildRole role,
- BlockReopenQueue *reopen_queue,
+ BdrvChildRole role, BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared)
{
- assert(child_class == &child_of_bds);
-
if (role & BDRV_CHILD_FILTERED) {
- bdrv_filter_default_perms(bs, c, child_class, role, reopen_queue,
+ bdrv_filter_default_perms(bs, c, role, reopen_queue,
perm, shared, nperm, nshared);
} else if (role & BDRV_CHILD_COW) {
- bdrv_default_perms_for_backing(bs, c, child_class, role, reopen_queue,
+ bdrv_default_perms_for_backing(bs, c, role, reopen_queue,
perm, shared, nperm, nshared);
} else if (role & BDRV_CHILD_METADATA) {
- bdrv_default_perms_for_metadata(bs, c, child_class, role, reopen_queue,
+ bdrv_default_perms_for_metadata(bs, c, role, reopen_queue,
perm, shared, nperm, nshared);
} else if (role & BDRV_CHILD_DATA) {
- bdrv_default_perms_for_data(bs, c, child_class, role, reopen_queue,
+ bdrv_default_perms_for_data(bs, c, role, reopen_queue,
perm, shared, nperm, nshared);
} else {
g_assert_not_reached();
@@ -2577,7 +2570,7 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
assert(parent_bs->drv);
- bdrv_child_perm(parent_bs, child_bs, NULL, child_class, child_role, NULL,
+ bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
perm, shared_perm, &perm, &shared_perm);
child = bdrv_root_attach_child(child_bs, child_name, child_class,
@@ -3650,7 +3643,7 @@ int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
if (state->replace_backing_bs && state->new_backing_bs) {
uint64_t nperm, nshared;
bdrv_child_perm(state->bs, state->new_backing_bs,
- NULL, &child_of_bds, bdrv_backing_role(state->bs),
+ NULL, bdrv_backing_role(state->bs),
bs_queue, state->perm, state->shared_perm,
&nperm, &nshared);
ret = bdrv_check_update_perm(state->new_backing_bs, NULL,
@@ -3764,7 +3757,7 @@ static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
} else {
uint64_t nperm, nshared;
- bdrv_child_perm(parent->state.bs, bs, c, c->klass, c->role, q,
+ bdrv_child_perm(parent->state.bs, bs, c, c->role, q,
parent->state.perm, parent->state.shared_perm,
&nperm, &nshared);
diff --git a/block/backup-top.c b/block/backup-top.c
index 00dbad44b5..351ced39ea 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -121,7 +121,6 @@ static void backup_top_refresh_filename(BlockDriverState *bs)
}
static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
@@ -153,7 +152,7 @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
*nperm = BLK_PERM_WRITE;
} else {
/* Source child */
- bdrv_default_perms(bs, c, child_class, role, reopen_queue,
+ bdrv_default_perms(bs, c, role, reopen_queue,
perm, shared, nperm, nshared);
if (perm & BLK_PERM_WRITE) {
diff --git a/block/blkdebug.c b/block/blkdebug.c
index a925d8295e..7194bc7f06 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -995,7 +995,6 @@ static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,
}
static void blkdebug_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
@@ -1003,7 +1002,7 @@ static void blkdebug_child_perm(BlockDriverState *bs, BdrvChild *c,
{
BDRVBlkdebugState *s = bs->opaque;
- bdrv_default_perms(bs, c, child_class, role, reopen_queue,
+ bdrv_default_perms(bs, c, role, reopen_queue,
perm, shared, nperm, nshared);
*nperm |= s->take_child_perms;
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index 8684fb1c74..6753bd9a3e 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -283,7 +283,6 @@ static int64_t blk_log_writes_getlength(BlockDriverState *bs)
}
static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *ro_q,
uint64_t perm, uint64_t shrd,
@@ -295,7 +294,7 @@ static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
return;
}
- bdrv_default_perms(bs, c, child_class, role, ro_q, perm, shrd,
+ bdrv_default_perms(bs, c, role, ro_q, perm, shrd,
nperm, nshrd);
}
diff --git a/block/commit.c b/block/commit.c
index 6d094c8cd1..7bf05e69da 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -223,7 +223,6 @@ static void bdrv_commit_top_refresh_filename(BlockDriverState *bs)
}
static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
diff --git a/block/copy-on-read.c b/block/copy-on-read.c
index c857ea0da7..a6e3c74a68 100644
--- a/block/copy-on-read.c
+++ b/block/copy-on-read.c
@@ -52,7 +52,6 @@ static int cor_open(BlockDriverState *bs, QDict *options, int flags,
#define PERM_UNCHANGED (BLK_PERM_ALL & ~PERM_PASSTHROUGH)
static void cor_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
diff --git a/block/mirror.c b/block/mirror.c
index 25c5e8b622..78f5939fac 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -1484,7 +1484,6 @@ static void bdrv_mirror_top_refresh_filename(BlockDriverState *bs)
}
static void bdrv_mirror_top_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
diff --git a/block/quorum.c b/block/quorum.c
index 616ac3a927..7cf7ab1546 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -1153,7 +1153,6 @@ static char *quorum_dirname(BlockDriverState *bs, Error **errp)
}
static void quorum_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
diff --git a/block/replication.c b/block/replication.c
index ec512ae1c3..5843367944 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -161,7 +161,6 @@ static void replication_close(BlockDriverState *bs)
}
static void replication_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
diff --git a/block/vvfat.c b/block/vvfat.c
index d4f4218924..6e36ad3175 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3213,7 +3213,6 @@ err:
}
static void vvfat_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
@@ -3221,8 +3220,7 @@ static void vvfat_child_perm(BlockDriverState *bs, BdrvChild *c,
{
BDRVVVFATState *s = bs->opaque;
- assert(c == s->qcow ||
- (child_class == &child_of_bds && (role & BDRV_CHILD_COW)));
+ assert(c == s->qcow || (role & BDRV_CHILD_COW));
if (c == s->qcow) {
/* This is a private node, nobody should try to attach to it */
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 1609e40b58..9c58b64903 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -563,7 +563,6 @@ struct BlockDriver {
* @reopen_queue.
*/
void (*bdrv_child_perm)(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t parent_perm, uint64_t parent_shared,
@@ -1261,8 +1260,7 @@ bool bdrv_recurse_can_replace(BlockDriverState *bs,
* child_of_bds child class and set an appropriate BdrvChildRole.
*/
void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class, BdrvChildRole role,
- BlockReopenQueue *reopen_queue,
+ BdrvChildRole role, BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
uint64_t *nperm, uint64_t *nshared);
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index 655fd0d085..1107271840 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -85,23 +85,6 @@ static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
return 0;
}
-static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
- BdrvChildRole role,
- BlockReopenQueue *reopen_queue,
- uint64_t perm, uint64_t shared,
- uint64_t *nperm, uint64_t *nshared)
-{
- /*
- * bdrv_default_perms() accepts nothing else, so disguise
- * detach_by_driver_cb_parent.
- */
- child_class = &child_of_bds;
-
- bdrv_default_perms(bs, c, child_class, role, reopen_queue,
- perm, shared, nperm, nshared);
-}
-
static int bdrv_test_change_backing_file(BlockDriverState *bs,
const char *backing_file,
const char *backing_fmt)
@@ -119,7 +102,7 @@ static BlockDriver bdrv_test = {
.bdrv_co_drain_begin = bdrv_test_co_drain_begin,
.bdrv_co_drain_end = bdrv_test_co_drain_end,
- .bdrv_child_perm = bdrv_test_child_perm,
+ .bdrv_child_perm = bdrv_default_perms,
.bdrv_change_backing_file = bdrv_test_change_backing_file,
};
diff --git a/tests/test-bdrv-graph-mod.c b/tests/test-bdrv-graph-mod.c
index a2d0318b16..f93f3168b0 100644
--- a/tests/test-bdrv-graph-mod.c
+++ b/tests/test-bdrv-graph-mod.c
@@ -30,7 +30,6 @@ static BlockDriver bdrv_pass_through = {
};
static void no_perm_default_perms(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildClass *child_class,
BdrvChildRole role,
BlockReopenQueue *reopen_queue,
uint64_t perm, uint64_t shared,
--
2.24.1
^ permalink raw reply related [flat|nested] 63+ messages in thread