ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

block: Purify .bdrv_refresh_filename() 

Currently, BlockDriver.bdrv_refresh_filename() is supposed to both
refresh the filename (BDS.exact_filename) and set BDS.full_open_options.
Now that we have generic code in the central bdrv_refresh_filename() for
creating BDS.full_open_options, we can drop the latter part from all
BlockDriver.bdrv_refresh_filename() implementations.

This also means that we can drop all of the existing default code for
this from the global bdrv_refresh_filename() itself.

Furthermore, we now have to call BlockDriver.bdrv_refresh_filename()
after having set BDS.full_open_options, because the block driver's
implementation should now be allowed to depend on BDS.full_open_options
being set correctly.

Finally, with this patch we can drop the @options parameter from
BlockDriver.bdrv_refresh_filename(); also, add a comment on this
function's purpose in block/block_int.h while touching its interface.

This completely obsoletes blklogwrite's implementation of
.bdrv_refresh_filename().

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190201192935.18394-25-mreitz@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
This commit is contained in:
Max Reitz 2019-02-01 20:29:28 +01:00
parent 97e2f021f8
commit 998b3a1e5a
14 changed files with 79 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
block.c
View File

@ -5621,33 +5621,6 @@ static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs)
return found_any; return found_any;
} }
static bool append_open_options(QDict *d, BlockDriverState *bs)
{
const QDictEntry *entry;
QemuOptDesc *desc;
bool found_any = false;
for (entry = qdict_first(bs->options); entry;
entry = qdict_next(bs->options, entry))
{
/* Exclude all non-driver-specific options */
for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
if (!strcmp(qdict_entry_key(entry), desc->name)) {
break;
}
}
if (desc->name) {
continue;
}
qdict_put_obj(d, qdict_entry_key(entry),
qobject_ref(qdict_entry_value(entry)));
found_any = true;
}
return found_any;
}
/* Note: This function may return false positives; it may return true /* Note: This function may return false positives; it may return true
* even if opening the backing file specified by bs's image header * even if opening the backing file specified by bs's image header
* would result in exactly bs->backing. */ * would result in exactly bs->backing. */
@ -5681,6 +5654,8 @@ void bdrv_refresh_filename(BlockDriverState *bs)
BdrvChild *child; BdrvChild *child;
QDict *opts; QDict *opts;
bool backing_overridden; bool backing_overridden;
bool generate_json_filename; /* Whether our default implementation should
fill exact_filename (false) or not (true) */
if (!drv) { if (!drv) {
return; return;
@ -5716,90 +5691,10 @@ void bdrv_refresh_filename(BlockDriverState *bs)
backing_overridden = false; backing_overridden = false;
} }
if (drv->bdrv_refresh_filename) {
/* Obsolete information is of no use here, so drop the old file name
* information before refreshing it */
bs->exact_filename[0] = '\0';
if (bs->full_open_options) {
qobject_unref(bs->full_open_options);
bs->full_open_options = NULL;
}
opts = qdict_new();
append_open_options(opts, bs);
drv->bdrv_refresh_filename(bs, opts);
qobject_unref(opts);
} else if (bs->file) {
/* Try to reconstruct valid information from the underlying file */
bool has_open_options;
bs->exact_filename[0] = '\0';
if (bs->full_open_options) {
qobject_unref(bs->full_open_options);
bs->full_open_options = NULL;
}
opts = qdict_new();
has_open_options = append_open_options(opts, bs);
has_open_options |= backing_overridden;
/* If no specific options have been given for this BDS, the filename of
* the underlying file should suffice for this one as well */
if (bs->file->bs->exact_filename[0] && !has_open_options) {
strcpy(bs->exact_filename, bs->file->bs->exact_filename);
}
/* Reconstructing the full options QDict is simple for most format block
* drivers, as long as the full options are known for the underlying
* file BDS. The full options QDict of that file BDS should somehow
* contain a representation of the filename, therefore the following
* suffices without querying the (exact_)filename of this BDS. */
if (bs->file->bs->full_open_options &&
(!bs->backing || bs->backing->bs->full_open_options))
{
qdict_put_str(opts, "driver", drv->format_name);
qdict_put(opts, "file",
qobject_ref(bs->file->bs->full_open_options));
if (bs->backing) {
qdict_put(opts, "backing",
qobject_ref(bs->backing->bs->full_open_options));
} else if (backing_overridden) {
qdict_put_null(opts, "backing");
}
bs->full_open_options = opts;
} else {
qobject_unref(opts);
}
} else if (!bs->full_open_options && qdict_size(bs->options)) {
/* There is no underlying file BDS (at least referenced by BDS.file),
* so the full options QDict should be equal to the options given
* specifically for this block device when it was opened (plus the
* driver specification).
* Because those options don't change, there is no need to update
* full_open_options when it's already set. */
opts = qdict_new();
append_open_options(opts, bs);
qdict_put_str(opts, "driver", drv->format_name);
if (bs->exact_filename[0]) {
/* This may not work for all block protocol drivers (some may
* require this filename to be parsed), but we have to find some
* default solution here, so just include it. If some block driver
* does not support pure options without any filename at all or
* needs some special format of the options QDict, it needs to
* implement the driver-specific bdrv_refresh_filename() function.
*/
qdict_put_str(opts, "filename", bs->exact_filename);
}
bs->full_open_options = opts;
}
/* Gather the options QDict */ /* Gather the options QDict */
opts = qdict_new(); opts = qdict_new();
append_strong_runtime_options(opts, bs); generate_json_filename = append_strong_runtime_options(opts, bs);
generate_json_filename |= backing_overridden;
if (drv->bdrv_gather_child_options) { if (drv->bdrv_gather_child_options) {
/* Some block drivers may not want to present all of their children's /* Some block drivers may not want to present all of their children's
@ -5825,6 +5720,24 @@ void bdrv_refresh_filename(BlockDriverState *bs)
qobject_unref(bs->full_open_options); qobject_unref(bs->full_open_options);
bs->full_open_options = opts; bs->full_open_options = opts;
if (drv->bdrv_refresh_filename) {
/* Obsolete information is of no use here, so drop the old file name
* information before refreshing it */
bs->exact_filename[0] = '\0';
drv->bdrv_refresh_filename(bs);
} else if (bs->file) {
/* Try to reconstruct valid information from the underlying file */
bs->exact_filename[0] = '\0';
/* If no specific options have been given for this BDS, the filename of
* the underlying file should suffice for this one as well */
if (bs->file->bs->exact_filename[0] && !generate_json_filename) {
strcpy(bs->exact_filename, bs->file->bs->exact_filename);
}
}
if (bs->exact_filename[0]) { if (bs->exact_filename[0]) {
pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename); pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
} else { } else {

54
block/blkdebug.c
View File

@ -811,51 +811,37 @@ static int64_t blkdebug_getlength(BlockDriverState *bs)
return bdrv_getlength(bs->file->bs); return bdrv_getlength(bs->file->bs);
} }
static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options) static void blkdebug_refresh_filename(BlockDriverState *bs)
{ {
BDRVBlkdebugState *s = bs->opaque; BDRVBlkdebugState *s = bs->opaque;
QDict *opts;
const QDictEntry *e; const QDictEntry *e;
bool force_json = false; int ret;
for (e = qdict_first(options); e; e = qdict_next(options, e)) { if (!bs->file->bs->exact_filename[0]) {
if (strcmp(qdict_entry_key(e), "config") &&
strcmp(qdict_entry_key(e), "x-image"))
{
force_json = true;
break;
}
}
if (force_json && !bs->file->bs->full_open_options) {
/* The config file cannot be recreated, so creating a plain filename
* is impossible */
return; return;
} }
if (!force_json && bs->file->bs->exact_filename[0]) { for (e = qdict_first(bs->full_open_options); e;
int ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename), e = qdict_next(bs->full_open_options, e))
"blkdebug:%s:%s", s->config_file ?: "", {
bs->file->bs->exact_filename); /* Real child options are under "image", but "x-image" may
if (ret >= sizeof(bs->exact_filename)) { * contain a filename */
/* An overflow makes the filename unusable, so do not report any */ if (strcmp(qdict_entry_key(e), "config") &&
bs->exact_filename[0] = 0; strcmp(qdict_entry_key(e), "image") &&
strcmp(qdict_entry_key(e), "x-image") &&
strcmp(qdict_entry_key(e), "driver"))
{
return;
} }
} }
opts = qdict_new(); ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
qdict_put_str(opts, "driver", "blkdebug"); "blkdebug:%s:%s",
s->config_file ?: "", bs->file->bs->exact_filename);
qdict_put(opts, "image", qobject_ref(bs->file->bs->full_open_options)); if (ret >= sizeof(bs->exact_filename)) {
/* An overflow makes the filename unusable, so do not report any */
for (e = qdict_first(options); e; e = qdict_next(options, e)) { bs->exact_filename[0] = 0;
if (strcmp(qdict_entry_key(e), "x-image")) {
qdict_put_obj(opts, qdict_entry_key(e),
qobject_ref(qdict_entry_value(e)));
}
} }
bs->full_open_options = opts;
} }
static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp) static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp)

22
block/blklogwrites.c
View File

@ -280,27 +280,6 @@ static int64_t blk_log_writes_getlength(BlockDriverState *bs)
return bdrv_getlength(bs->file->bs); return bdrv_getlength(bs->file->bs);
} }
static void blk_log_writes_refresh_filename(BlockDriverState *bs,
QDict *options)
{
BDRVBlkLogWritesState *s = bs->opaque;
if (bs->file->bs->full_open_options
&& s->log_file->bs->full_open_options)
{
QDict *opts = qdict_new();
qdict_put_str(opts, "driver", "blklogwrites");
qobject_ref(bs->file->bs->full_open_options);
qdict_put(opts, "file", bs->file->bs->full_open_options);
qobject_ref(s->log_file->bs->full_open_options);
qdict_put(opts, "log", s->log_file->bs->full_open_options);
qdict_put_int(opts, "log-sector-size", s->sectorsize);
bs->full_open_options = opts;
}
}
static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c, static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
const BdrvChildRole *role, const BdrvChildRole *role,
BlockReopenQueue *ro_q, BlockReopenQueue *ro_q,
@ -531,7 +510,6 @@ static BlockDriver bdrv_blk_log_writes = {
.bdrv_open = blk_log_writes_open, .bdrv_open = blk_log_writes_open,
.bdrv_close = blk_log_writes_close, .bdrv_close = blk_log_writes_close,
.bdrv_getlength = blk_log_writes_getlength, .bdrv_getlength = blk_log_writes_getlength,
.bdrv_refresh_filename = blk_log_writes_refresh_filename,
.bdrv_child_perm = blk_log_writes_child_perm, .bdrv_child_perm = blk_log_writes_child_perm,
.bdrv_refresh_limits = blk_log_writes_refresh_limits, .bdrv_refresh_limits = blk_log_writes_refresh_limits,

16
block/blkverify.c
View File

@ -281,24 +281,10 @@ static bool blkverify_recurse_is_first_non_filter(BlockDriverState *bs,
return bdrv_recurse_is_first_non_filter(s->test_file->bs, candidate); return bdrv_recurse_is_first_non_filter(s->test_file->bs, candidate);
} }
static void blkverify_refresh_filename(BlockDriverState *bs, QDict *options) static void blkverify_refresh_filename(BlockDriverState *bs)
{ {
BDRVBlkverifyState *s = bs->opaque; BDRVBlkverifyState *s = bs->opaque;
if (bs->file->bs->full_open_options
&& s->test_file->bs->full_open_options)
{
QDict *opts = qdict_new();
qdict_put_str(opts, "driver", "blkverify");
qdict_put(opts, "raw",
qobject_ref(bs->file->bs->full_open_options));
qdict_put(opts, "test",
qobject_ref(s->test_file->bs->full_open_options));
bs->full_open_options = opts;
}
if (bs->file->bs->exact_filename[0] if (bs->file->bs->exact_filename[0]
&& s->test_file->bs->exact_filename[0]) && s->test_file->bs->exact_filename[0])
{ {

2
block/commit.c
View File

@ -230,7 +230,7 @@ static int coroutine_fn bdrv_commit_top_preadv(BlockDriverState *bs,
return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags); return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags);
} }
static void bdrv_commit_top_refresh_filename(BlockDriverState *bs, QDict *opts) static void bdrv_commit_top_refresh_filename(BlockDriverState *bs)
{ {
pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
bs->backing->bs->filename); bs->backing->bs->filename);

2
block/mirror.c
View File

@ -1431,7 +1431,7 @@ static int coroutine_fn bdrv_mirror_top_pdiscard(BlockDriverState *bs,
NULL, 0); NULL, 0);
} }
static void bdrv_mirror_top_refresh_filename(BlockDriverState *bs, QDict *opts) static void bdrv_mirror_top_refresh_filename(BlockDriverState *bs)
{ {
if (bs->backing == NULL) { if (bs->backing == NULL) {
/* we can be here after failed bdrv_attach_child in /* we can be here after failed bdrv_attach_child in

23
block/nbd.c
View File

@ -477,12 +477,9 @@ static void nbd_attach_aio_context(BlockDriverState *bs,
nbd_client_attach_aio_context(bs, new_context); nbd_client_attach_aio_context(bs, new_context);
} }
static void nbd_refresh_filename(BlockDriverState *bs, QDict *options) static void nbd_refresh_filename(BlockDriverState *bs)
{ {
BDRVNBDState *s = bs->opaque; BDRVNBDState *s = bs->opaque;
QDict *opts = qdict_new();
QObject *saddr_qdict;
Visitor *ov;
const char *host = NULL, *port = NULL, *path = NULL; const char *host = NULL, *port = NULL, *path = NULL;
if (s->saddr->type == SOCKET_ADDRESS_TYPE_INET) { if (s->saddr->type == SOCKET_ADDRESS_TYPE_INET) {
@ -495,8 +492,6 @@ static void nbd_refresh_filename(BlockDriverState *bs, QDict *options)
path = s->saddr->u.q_unix.path; path = s->saddr->u.q_unix.path;
} /* else can't represent as pseudo-filename */ } /* else can't represent as pseudo-filename */
qdict_put_str(opts, "driver", "nbd");
if (path && s->export) { if (path && s->export) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename), snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd+unix:///%s?socket=%s", s->export, path); "nbd+unix:///%s?socket=%s", s->export, path);
@ -510,22 +505,6 @@ static void nbd_refresh_filename(BlockDriverState *bs, QDict *options)
snprintf(bs->exact_filename, sizeof(bs->exact_filename), snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nbd://%s:%s", host, port); "nbd://%s:%s", host, port);
} }
ov = qobject_output_visitor_new(&saddr_qdict);
visit_type_SocketAddress(ov, NULL, &s->saddr, &error_abort);
visit_complete(ov, &saddr_qdict);
visit_free(ov);
qdict_put_obj(opts, "server", saddr_qdict);
if (s->export) {
qdict_put_str(opts, "export", s->export);
}
if (s->tlscredsid) {
qdict_put_str(opts, "tls-creds", s->tlscredsid);
}
qdict_flatten(opts);
bs->full_open_options = opts;
} }
static char *nbd_dirname(BlockDriverState *bs, Error **errp) static char *nbd_dirname(BlockDriverState *bs, Error **errp)

36
block/nfs.c
View File

@ -799,14 +799,9 @@ static int nfs_reopen_prepare(BDRVReopenState *state,
return 0; return 0;
} }
static void nfs_refresh_filename(BlockDriverState *bs, QDict *options) static void nfs_refresh_filename(BlockDriverState *bs)
{ {
NFSClient *client = bs->opaque; NFSClient *client = bs->opaque;
QDict *opts = qdict_new();
QObject *server_qdict;
Visitor *ov;
qdict_put_str(opts, "driver", "nfs");
if (client->uid && !client->gid) { if (client->uid && !client->gid) {
snprintf(bs->exact_filename, sizeof(bs->exact_filename), snprintf(bs->exact_filename, sizeof(bs->exact_filename),
@ -824,35 +819,6 @@ static void nfs_refresh_filename(BlockDriverState *bs, QDict *options)
snprintf(bs->exact_filename, sizeof(bs->exact_filename), snprintf(bs->exact_filename, sizeof(bs->exact_filename),
"nfs://%s%s", client->server->host, client->path); "nfs://%s%s", client->server->host, client->path);
} }
ov = qobject_output_visitor_new(&server_qdict);
visit_type_NFSServer(ov, NULL, &client->server, &error_abort);
visit_complete(ov, &server_qdict);
qdict_put_obj(opts, "server", server_qdict);
qdict_put_str(opts, "path", client->path);
if (client->uid) {
qdict_put_int(opts, "user", client->uid);
}
if (client->gid) {
qdict_put_int(opts, "group", client->gid);
}
if (client->tcp_syncnt) {
qdict_put_int(opts, "tcp-syn-cnt", client->tcp_syncnt);
}
if (client->readahead) {
qdict_put_int(opts, "readahead-size", client->readahead);
}
if (client->pagecache) {
qdict_put_int(opts, "page-cache-size", client->pagecache);
}
if (client->debug) {
qdict_put_int(opts, "debug", client->debug);
}
visit_free(ov);
qdict_flatten(opts);
bs->full_open_options = opts;
} }
static char *nfs_dirname(BlockDriverState *bs, Error **errp) static char *nfs_dirname(BlockDriverState *bs, Error **errp)

20
block/null.c
View File

@ -239,17 +239,23 @@ static int coroutine_fn null_co_block_status(BlockDriverState *bs,
return ret; return ret;
} }
static void null_refresh_filename(BlockDriverState *bs, QDict *opts) static void null_refresh_filename(BlockDriverState *bs)
{ {
qdict_del(opts, "filename"); const QDictEntry *e;
if (!qdict_size(opts)) { for (e = qdict_first(bs->full_open_options); e;
snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s://", e = qdict_next(bs->full_open_options, e))
bs->drv->format_name); {
/* These options can be ignored */
if (strcmp(qdict_entry_key(e), "filename") &&
strcmp(qdict_entry_key(e), "driver"))
{
return;
}
} }
qdict_put_str(opts, "driver", bs->drv->format_name); snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s://",
bs->full_open_options = qobject_ref(opts); bs->drv->format_name);
} }
static const char *const null_strong_runtime_opts[] = { static const char *const null_strong_runtime_opts[] = {

20
block/nvme.c
View File

@ -1053,17 +1053,23 @@ static int nvme_reopen_prepare(BDRVReopenState *reopen_state,
return 0; return 0;
} }
static void nvme_refresh_filename(BlockDriverState *bs, QDict *opts) static void nvme_refresh_filename(BlockDriverState *bs)
{ {
qdict_del(opts, "filename"); const QDictEntry *e;
if (!qdict_size(opts)) { for (e = qdict_first(bs->full_open_options); e;
snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s://", e = qdict_next(bs->full_open_options, e))
bs->drv->format_name); {
/* These options can be ignored */
if (strcmp(qdict_entry_key(e), "filename") &&
strcmp(qdict_entry_key(e), "driver"))
{
return;
}
} }
qdict_put_str(opts, "driver", bs->drv->format_name); snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s://",
bs->full_open_options = qobject_ref(opts); bs->drv->format_name);
} }
static void nvme_refresh_limits(BlockDriverState *bs, Error **errp) static void nvme_refresh_limits(BlockDriverState *bs, Error **errp)

30
block/quorum.c
View File

@ -1065,35 +1065,6 @@ static void quorum_del_child(BlockDriverState *bs, BdrvChild *child,
bdrv_drained_end(bs); bdrv_drained_end(bs);
} }
static void quorum_refresh_filename(BlockDriverState *bs, QDict *options)
{
BDRVQuorumState *s = bs->opaque;
QDict *opts;
QList *children;
int i;
for (i = 0; i < s->num_children; i++) {
if (!s->children[i]->bs->full_open_options) {
return;
}
}
children = qlist_new();
for (i = 0; i < s->num_children; i++) {
qlist_append(children,
qobject_ref(s->children[i]->bs->full_open_options));
}
opts = qdict_new();
qdict_put_str(opts, "driver", "quorum");
qdict_put_int(opts, QUORUM_OPT_VOTE_THRESHOLD, s->threshold);
qdict_put_bool(opts, QUORUM_OPT_BLKVERIFY, s->is_blkverify);
qdict_put_bool(opts, QUORUM_OPT_REWRITE, s->rewrite_corrupted);
qdict_put(opts, "children", children);
bs->full_open_options = opts;
}
static void quorum_gather_child_options(BlockDriverState *bs, QDict *target, static void quorum_gather_child_options(BlockDriverState *bs, QDict *target,
bool backing_overridden) bool backing_overridden)
{ {
@ -1159,7 +1130,6 @@ static BlockDriver bdrv_quorum = {
.bdrv_open = quorum_open, .bdrv_open = quorum_open,
.bdrv_close = quorum_close, .bdrv_close = quorum_close,
.bdrv_refresh_filename = quorum_refresh_filename,
.bdrv_gather_child_options = quorum_gather_child_options, .bdrv_gather_child_options = quorum_gather_child_options,
.bdrv_dirname = quorum_dirname, .bdrv_dirname = quorum_dirname,

6
include/block/block_int.h
View File

@ -139,7 +139,11 @@ struct BlockDriver {
Error **errp); Error **errp);
int (*bdrv_make_empty)(BlockDriverState *bs); int (*bdrv_make_empty)(BlockDriverState *bs);
void (*bdrv_refresh_filename)(BlockDriverState *bs, QDict *options); /*
* Refreshes the bs->exact_filename field. If that is impossible,
* bs->exact_filename has to be left empty.
*/
void (*bdrv_refresh_filename)(BlockDriverState *bs);
/* /*
* Gathers the open options for all children into @target. * Gathers the open options for all children into @target.

4
tests/qemu-iotests/228
View File

@ -230,10 +230,6 @@ with iotests.FilePath('base.img') as base_img_path, \
overlay='node0') overlay='node0')
# This should give us the original plain result # This should give us the original plain result
# FIXME: Currently, it yields a json:{} filename even though it
# only contains a @driver and a @file entry, so a plain
# filename would obviously suffice. This is fixed by a
# future patch.
log_node_info(vm.node_info('node0')) log_node_info(vm.node_info('node0'))

2
tests/qemu-iotests/228.out
View File

@ -74,7 +74,7 @@ bs->backing: (none)
{"execute": "blockdev-snapshot", "arguments": {"node": "original-backing", "overlay": "node0"}} {"execute": "blockdev-snapshot", "arguments": {"node": "original-backing", "overlay": "node0"}}
{"return": {}} {"return": {}}
bs->filename: json:{"driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-top.img"}} bs->filename: TEST_DIR/PID-top.img
bs->backing_file: TEST_DIR/PID-base.img bs->backing_file: TEST_DIR/PID-base.img
bs->backing->bs->filename: TEST_DIR/PID-base.img bs->backing->bs->filename: TEST_DIR/PID-base.img