mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

block: introduce bdrv_open_file_child() helper

Browse Source 
Almost all drivers call bdrv_open_child() similarly. Let's create a
helper for this.

The only not updated drivers that call bdrv_open_child() to set
bs->file are raw-format and snapshot-access:
    raw-format sometimes want to have filtered child but
        don't set drv->is_filter to true.
    snapshot-access wants only DATA | PRIMARY

Possibly we should implement drv->is_filter_func() handler, to consider
raw-format as filter when it works as filter.. But it's another story.

Note also, that we decrease assignments to bs->file in code: it helps
us restrict modifying this field in further commit.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220726201134.924743-3-vsementsov@yandex-team.ru>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2022-07-26 23:11:21 +03:00 committed by Kevin Wolf
parent 046fd84fac
commit 8393078032
24 changed files with 95 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
block.c
View File

@ -3673,6 +3673,27 @@ BdrvChild *bdrv_open_child(const char *filename,
errp); errp);
} }
/*
* Wrapper on bdrv_open_child() for most popular case: open primary child of bs.
*/
int bdrv_open_file_child(const char *filename,
QDict *options, const char *bdref_key,
BlockDriverState *parent, Error **errp)
{
BdrvChildRole role;
/* commit_top and mirror_top don't use this function */
assert(!parent->drv->filtered_child_is_backing);
role = parent->drv->is_filter ?
(BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY) : BDRV_CHILD_IMAGE;
parent->file = bdrv_open_child(filename, options, bdref_key, parent,
&child_of_bds, role, false, errp);
return parent->file ? 0 : -EINVAL;
}
/* /*
* TODO Future callers may need to specify parent/child_class in order for * 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. * option inheritance to work. Existing callers use it for the root node.

9
block/blkdebug.c
View File

@ -503,12 +503,9 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
} }
/* Open the image file */ /* Open the image file */
bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image", ret = bdrv_open_file_child(qemu_opt_get(opts, "x-image"), options, "image",
bs, &child_of_bds, bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp);
if (!bs->file) {
ret = -EINVAL;
goto out; goto out;
} }

7
block/blklogwrites.c
View File

@ -155,11 +155,8 @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
} }
/* Open the file */ /* Open the file */
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, false, if (ret < 0) {
errp);
if (!bs->file) {
ret = -EINVAL;
goto fail; goto fail;
} }

7
block/blkreplay.c
View File

@ -26,11 +26,8 @@ static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
int ret; int ret;
/* Open the image file */ /* Open the image file */
bs->file = bdrv_open_child(NULL, options, "image", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "image", bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp);
if (!bs->file) {
ret = -EINVAL;
goto fail; goto fail;
} }

9
block/blkverify.c
View File

@ -122,12 +122,9 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags,
} }
/* Open the raw file */ /* Open the raw file */
bs->file = bdrv_open_child(qemu_opt_get(opts, "x-raw"), options, "raw", ret = bdrv_open_file_child(qemu_opt_get(opts, "x-raw"), options, "raw",
bs, &child_of_bds, bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp);
if (!bs->file) {
ret = -EINVAL;
goto fail; goto fail;
} }

7
block/bochs.c
View File

@ -110,10 +110,9 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
return ret; return ret;
} }
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
ret = bdrv_pread(bs->file, 0, sizeof(bochs), &bochs, 0); ret = bdrv_pread(bs->file, 0, sizeof(bochs), &bochs, 0);

7
block/cloop.c
View File

@ -71,10 +71,9 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
return ret; return ret;
} }
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
/* read header */ /* read header */

9
block/copy-before-write.c
View File

@ -412,6 +412,7 @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
int64_t cluster_size; int64_t cluster_size;
g_autoptr(BlockdevOptions) full_opts = NULL; g_autoptr(BlockdevOptions) full_opts = NULL;
BlockdevOptionsCbw *opts; BlockdevOptionsCbw *opts;
int ret;
full_opts = cbw_parse_options(options, errp); full_opts = cbw_parse_options(options, errp);
if (!full_opts) { if (!full_opts) {
@ -420,11 +421,9 @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
assert(full_opts->driver == BLOCKDEV_DRIVER_COPY_BEFORE_WRITE); assert(full_opts->driver == BLOCKDEV_DRIVER_COPY_BEFORE_WRITE);
opts = &full_opts->u.copy_before_write; opts = &full_opts->u.copy_before_write;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp); return ret;
if (!bs->file) {
return -EINVAL;
} }
s->target = bdrv_open_child(NULL, options, "target", bs, &child_of_bds, s->target = bdrv_open_child(NULL, options, "target", bs, &child_of_bds,

9
block/copy-on-read.c
View File

@ -41,12 +41,11 @@ static int cor_open(BlockDriverState *bs, QDict *options, int flags,
BDRVStateCOR *state = bs->opaque; BDRVStateCOR *state = bs->opaque;
/* Find a bottom node name, if any */ /* Find a bottom node name, if any */
const char *bottom_node = qdict_get_try_str(options, "bottom"); const char *bottom_node = qdict_get_try_str(options, "bottom");
int ret;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp); return ret;
if (!bs->file) {
return -EINVAL;
} }
bs->supported_read_flags = BDRV_REQ_PREFETCH; bs->supported_read_flags = BDRV_REQ_PREFETCH;

11
block/crypto.c
View File

@ -261,15 +261,14 @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
{ {
BlockCrypto *crypto = bs->opaque; BlockCrypto *crypto = bs->opaque;
QemuOpts *opts = NULL; QemuOpts *opts = NULL;
int ret = -EINVAL; int ret;
QCryptoBlockOpenOptions *open_opts = NULL; QCryptoBlockOpenOptions *open_opts = NULL;
unsigned int cflags = 0; unsigned int cflags = 0;
QDict *cryptoopts = NULL; QDict *cryptoopts = NULL;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
bs->supported_write_flags = BDRV_REQ_FUA & bs->supported_write_flags = BDRV_REQ_FUA &
@ -277,6 +276,7 @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort); opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
if (!qemu_opts_absorb_qdict(opts, options, errp)) { if (!qemu_opts_absorb_qdict(opts, options, errp)) {
ret = -EINVAL;
goto cleanup; goto cleanup;
} }
@ -285,6 +285,7 @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
open_opts = block_crypto_open_opts_init(cryptoopts, errp); open_opts = block_crypto_open_opts_init(cryptoopts, errp);
if (!open_opts) { if (!open_opts) {
ret = -EINVAL;
goto cleanup; goto cleanup;
} }

7
block/dmg.c
View File

@ -440,10 +440,9 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
return ret; return ret;
} }
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
block_module_load_one("dmg-bz2"); block_module_load_one("dmg-bz2");

8
block/filter-compress.c
View File

@ -30,11 +30,9 @@
static int compress_open(BlockDriverState *bs, QDict *options, int flags, static int compress_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp) Error **errp)
{ {
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, int ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp); return ret;
if (!bs->file) {
return -EINVAL;
} }
if (!bs->file->bs->drv || !block_driver_can_compress(bs->file->bs->drv)) { if (!bs->file->bs->drv || !block_driver_can_compress(bs->file->bs->drv)) {

7
block/parallels.c
View File

@ -737,10 +737,9 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
Error *local_err = NULL; Error *local_err = NULL;
char *buf; char *buf;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
ret = bdrv_pread(bs->file, 0, sizeof(ph), &ph, 0); ret = bdrv_pread(bs->file, 0, sizeof(ph), &ph, 0);

9
block/preallocate.c
View File

@ -134,6 +134,7 @@ static int preallocate_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp) Error **errp)
{ {
BDRVPreallocateState *s = bs->opaque; BDRVPreallocateState *s = bs->opaque;
int ret;
/* /*
* s->data_end and friends should be initialized on permission update. * s->data_end and friends should be initialized on permission update.
@ -141,11 +142,9 @@ static int preallocate_open(BlockDriverState *bs, QDict *options, int flags,
*/ */
s->file_end = s->zero_start = s->data_end = -EINVAL; s->file_end = s->zero_start = s->data_end = -EINVAL;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp); return ret;
if (!bs->file) {
return -EINVAL;
} }
if (!preallocate_absorb_opts(&s->opts, options, bs->file->bs, errp)) { if (!preallocate_absorb_opts(&s->opts, options, bs->file->bs, errp)) {

6
block/qcow.c
View File

@ -121,10 +121,8 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
qdict_extract_subqdict(options, &encryptopts, "encrypt."); qdict_extract_subqdict(options, &encryptopts, "encrypt.");
encryptfmt = qdict_get_try_str(encryptopts, "format"); encryptfmt = qdict_get_try_str(encryptopts, "format");
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) {
ret = -EINVAL;
goto fail; goto fail;
} }

8
block/qcow2.c
View File

@ -1905,11 +1905,11 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
.errp = errp, .errp = errp,
.ret = -EINPROGRESS .ret = -EINPROGRESS
}; };
int ret;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
/* Initialise locks */ /* Initialise locks */

8
block/qed.c
View File

@ -561,11 +561,11 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
.errp = errp, .errp = errp,
.ret = -EINPROGRESS .ret = -EINPROGRESS
}; };
int ret;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
bdrv_qed_init_state(bs); bdrv_qed_init_state(bs);

8
block/replication.c
View File

@ -88,11 +88,9 @@ static int replication_open(BlockDriverState *bs, QDict *options,
const char *mode; const char *mode;
const char *top_id; const char *top_id;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp); return ret;
if (!bs->file) {
return -EINVAL;
} }
ret = -EINVAL; ret = -EINVAL;

8
block/throttle.c
View File

@ -78,11 +78,9 @@ static int throttle_open(BlockDriverState *bs, QDict *options,
char *group; char *group;
int ret; int ret;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY, if (ret < 0) {
false, errp); return ret;
if (!bs->file) {
return -EINVAL;
} }
bs->supported_write_flags = bs->file->bs->supported_write_flags | bs->supported_write_flags = bs->file->bs->supported_write_flags |
BDRV_REQ_WRITE_UNCHANGED; BDRV_REQ_WRITE_UNCHANGED;

7
block/vdi.c
View File

@ -377,10 +377,9 @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
int ret; int ret;
QemuUUID uuid_link, uuid_parent; QemuUUID uuid_link, uuid_parent;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
logout("\n"); logout("\n");

7
block/vhdx.c
View File

@ -1001,10 +1001,9 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
uint64_t signature; uint64_t signature;
Error *local_err = NULL; Error *local_err = NULL;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
s->bat = NULL; s->bat = NULL;

7
block/vmdk.c
View File

@ -1308,10 +1308,9 @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
BDRVVmdkState *s = bs->opaque; BDRVVmdkState *s = bs->opaque;
uint32_t magic; uint32_t magic;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
buf = vmdk_read_desc(bs->file, 0, errp); buf = vmdk_read_desc(bs->file, 0, errp);

7
block/vpc.c
View File

@ -233,10 +233,9 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
int ret; int ret;
int64_t bs_size; int64_t bs_size;
bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
BDRV_CHILD_IMAGE, false, errp); if (ret < 0) {
if (!bs->file) { return ret;
return -EINVAL;
} }
opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort); opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);

3
include/block/block-global-state.h
View File

@ -76,6 +76,9 @@ BdrvChild *bdrv_open_child(const char *filename,
const BdrvChildClass *child_class, const BdrvChildClass *child_class,
BdrvChildRole child_role, BdrvChildRole child_role,
bool allow_none, Error **errp); bool allow_none, Error **errp);
int bdrv_open_file_child(const char *filename,
QDict *options, const char *bdref_key,
BlockDriverState *parent, Error **errp);
BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp); BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp);
int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd, int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
Error **errp); Error **errp);