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 */
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,
/* 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);
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)
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)
/* 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 */
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,
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,
} 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);
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)
*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) {
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;
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)
}
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);
}
}
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)
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)
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)
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)
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)
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)
* 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
*/
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);
* 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);
* 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);
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)
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,
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)