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

QAPI patches for 2017-05-04 

-----BEGIN PGP SIGNATURE-----
 
 iQIcBAABAgAGBQJZEWy8AAoJEDhwtADrkYZTLAUP+wYCBQs3weLNpLWa37qpACTi
 1+MJ5T6xwpcdrGhSVKUoPXe4EigZpsKPcxfD0PxqFMqNjGfwvN6iERKMaQOD16kE
 Lgs3rE9Ls7SumWd9MEB838BbMBcZjOixyJCqIXc4bAT7kDGJ9S7wrSZJhbRmCaAn
 dNR+VHOZd0YWWlPiGhhy3oOtP7aClwH4AORdFRdaxv7DyvLB4CklRBmIumvi3HBv
 +kzIjlDBIkW9STsF/O/7k5NHWHv9SfSJ4Wz4Z1ROZIVhEic8TQafksRh0+YvZ2Mh
 smAhixXflibLF61ExVT7WbMwmasZ4chLzljq5z1K4nQiorcspmZ7x9Zit84TVaXC
 kBFOHWYb7w5KnnN9VwuQqJ8GAUERhcZJgnA93nlRVMtt46pczqN9lgPNvhAi9/uo
 jOaYpNEkYZvZB3m4PvTyB9771gL/i3HzfqN5jAdCR/+9l8wHC7zNtsWQ9gWm6vl5
 GBdvIjrX0v71scxJXiK93mj02gBROCRb977SU5DWC9SmrzK11a93XP2E8MXBSdJz
 eFLwY+rTPorbxjMco1PPkTWztoFXfj1tYzk8E6GVh8nOn6yijaNn+vaUdIOJYwox
 RbxWhvURy/nuoXnhPGFO5CkoxdSLMbOGWoq9OVz4mPITQH2jlOSDWpzuIoRCkNa5
 kPKw8cXlZQeztYHFq3Wt
 =KJss
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'armbru/tags/pull-qapi-2017-05-04-v3' into staging

QAPI patches for 2017-05-04

# gpg: Signature made Tue 09 May 2017 03:16:12 AM EDT
# gpg:                using RSA key 0x3870B400EB918653
# gpg: Good signature from "Markus Armbruster <armbru@redhat.com>"
# gpg:                 aka "Markus Armbruster <armbru@pond.sub.org>"
# Primary key fingerprint: 354B C8B3 D7EB 2A6B 6867  4E5F 3870 B400 EB91 8653

* armbru/tags/pull-qapi-2017-05-04-v3: (28 commits)
  qmp-shell: improve help
  qmp-shell: don't show version greeting if unavailable
  qmp-shell: Cope with query-commands error
  qmp-shell: add -N option to skip negotiate
  qmp-shell: add persistent command history
  qobject-input-visitor: Catch misuse of end_struct vs. end_list
  qapi: Document intended use of @name within alternate visits
  qobject-input-visitor: Document full_name_nth()
  qmp: Improve QMP dispatch error messages
  sockets: Delete unused helper socket_address_crumple()
  sockets: Limit SocketAddressLegacy to external interfaces
  sockets: Rename SocketAddressFlat to SocketAddress
  sockets: Rename SocketAddress to SocketAddressLegacy
  qapi: New QAPI_CLONE_MEMBERS()
  sockets: Prepare inet_parse() for flattened SocketAddress
  sockets: Prepare vsock_parse() for flattened SocketAddress
  test-qga: Actually test 0xff sync bytes
  fdc-test: Avoid deprecated 'change' command
  QemuOpts: Simplify qemu_opts_to_qdict()
  block: Simplify bdrv_append_temp_snapshot() logic
  ...

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
This commit is contained in:
Stefan Hajnoczi 2017-05-09 15:49:08 -04:00
parent 7ed57b6622 dcd3b25d65
commit 76d20ea0f1
71 changed files with 805 additions and 668 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
MAINTAINERS
View File

@ -1395,6 +1395,7 @@ S: Supported
F: qobject/ F: qobject/
F: include/qapi/qmp/ F: include/qapi/qmp/
X: include/qapi/qmp/dispatch.h X: include/qapi/qmp/dispatch.h
F: scripts/coccinelle/qobject.cocci
F: tests/check-qdict.c F: tests/check-qdict.c
F: tests/check-qfloat.c F: tests/check-qfloat.c
F: tests/check-qint.c F: tests/check-qint.c

68
block.c
View File

@ -974,16 +974,14 @@ static void update_flags_from_options(int *flags, QemuOpts *opts)
static void update_options_from_flags(QDict *options, int flags) static void update_options_from_flags(QDict *options, int flags)
{ {
if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) { if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
qdict_put(options, BDRV_OPT_CACHE_DIRECT, qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
qbool_from_bool(flags & BDRV_O_NOCACHE));
} }
if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) { if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH, qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
qbool_from_bool(flags & BDRV_O_NO_FLUSH)); flags & BDRV_O_NO_FLUSH);
} }
if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) { if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
qdict_put(options, BDRV_OPT_READ_ONLY, qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
qbool_from_bool(!(flags & BDRV_O_RDWR)));
} }
} }
@ -1399,7 +1397,7 @@ static int bdrv_fill_options(QDict **options, const char *filename,
/* Fetch the file name from the options QDict if necessary */ /* Fetch the file name from the options QDict if necessary */
if (protocol && filename) { if (protocol && filename) {
if (!qdict_haskey(*options, "filename")) { if (!qdict_haskey(*options, "filename")) {
qdict_put(*options, "filename", qstring_from_str(filename)); qdict_put_str(*options, "filename", filename);
parse_filename = true; parse_filename = true;
} else { } else {
error_setg(errp, "Can't specify 'file' and 'filename' options at " error_setg(errp, "Can't specify 'file' and 'filename' options at "
@ -1420,7 +1418,7 @@ static int bdrv_fill_options(QDict **options, const char *filename,
} }
drvname = drv->format_name; drvname = drv->format_name;
qdict_put(*options, "driver", qstring_from_str(drvname)); qdict_put_str(*options, "driver", drvname);
} else { } else {
error_setg(errp, "Must specify either driver or file"); error_setg(errp, "Must specify either driver or file");
return -EINVAL; return -EINVAL;
@ -2075,7 +2073,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
} }
if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) { if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
qdict_put(options, "driver", qstring_from_str(bs->backing_format)); qdict_put_str(options, "driver", bs->backing_format);
} }
backing_hd = bdrv_open_inherit(*backing_filename ? backing_filename : NULL, backing_hd = bdrv_open_inherit(*backing_filename ? backing_filename : NULL,
@ -2197,7 +2195,7 @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
char *tmp_filename = g_malloc0(PATH_MAX + 1); char *tmp_filename = g_malloc0(PATH_MAX + 1);
int64_t total_size; int64_t total_size;
QemuOpts *opts = NULL; QemuOpts *opts = NULL;
BlockDriverState *bs_snapshot; BlockDriverState *bs_snapshot = NULL;
Error *local_err = NULL; Error *local_err = NULL;
int ret; int ret;
@ -2230,38 +2228,32 @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
} }
/* Prepare options QDict for the temporary file */ /* Prepare options QDict for the temporary file */
qdict_put(snapshot_options, "file.driver", qdict_put_str(snapshot_options, "file.driver", "file");
qstring_from_str("file")); qdict_put_str(snapshot_options, "file.filename", tmp_filename);
qdict_put(snapshot_options, "file.filename", qdict_put_str(snapshot_options, "driver", "qcow2");
qstring_from_str(tmp_filename));
qdict_put(snapshot_options, "driver",
qstring_from_str("qcow2"));
bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp); bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
snapshot_options = NULL; snapshot_options = NULL;
if (!bs_snapshot) { if (!bs_snapshot) {
ret = -EINVAL;
goto out; goto out;
} }
/* bdrv_append() consumes a strong reference to bs_snapshot (i.e. it will /* bdrv_append() consumes a strong reference to bs_snapshot
* call bdrv_unref() on it), so in order to be able to return one, we have * (i.e. it will call bdrv_unref() on it) even on error, so in
* to increase bs_snapshot's refcount here */ * order to be able to return one, we have to increase
* bs_snapshot's refcount here */
bdrv_ref(bs_snapshot); bdrv_ref(bs_snapshot);
bdrv_append(bs_snapshot, bs, &local_err); bdrv_append(bs_snapshot, bs, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
ret = -EINVAL; bs_snapshot = NULL;
goto out; goto out;
} }
g_free(tmp_filename);
return bs_snapshot;
out: out:
QDECREF(snapshot_options); QDECREF(snapshot_options);
g_free(tmp_filename); g_free(tmp_filename);
return NULL; return bs_snapshot;
} }
/* /*
@ -2410,8 +2402,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
goto fail; goto fail;
} }
qdict_put(options, "file", qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
qstring_from_str(bdrv_get_node_name(file_bs)));
} }
} }
@ -2433,8 +2424,8 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
* sure to update both bs->options (which has the full effective * sure to update both bs->options (which has the full effective
* options for bs) and options (which has file.* already removed). * options for bs) and options (which has file.* already removed).
*/ */
qdict_put(bs->options, "driver", qstring_from_str(drv->format_name)); qdict_put_str(bs->options, "driver", drv->format_name);
qdict_put(options, "driver", qstring_from_str(drv->format_name)); qdict_put_str(options, "driver", drv->format_name);
} else if (!drv) { } else if (!drv) {
error_setg(errp, "Must specify either driver or file"); error_setg(errp, "Must specify either driver or file");
goto fail; goto fail;
@ -2810,12 +2801,12 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
* that they are checked at the end of this function. */ * that they are checked at the end of this function. */
value = qemu_opt_get(opts, "node-name"); value = qemu_opt_get(opts, "node-name");
if (value) { if (value) {
qdict_put(reopen_state->options, "node-name", qstring_from_str(value)); qdict_put_str(reopen_state->options, "node-name", value);
} }
value = qemu_opt_get(opts, "driver"); value = qemu_opt_get(opts, "driver");
if (value) { if (value) {
qdict_put(reopen_state->options, "driver", qstring_from_str(value)); qdict_put_str(reopen_state->options, "driver", value);
} }
/* If we are to stay read-only, do not allow permission change /* If we are to stay read-only, do not allow permission change
@ -4306,8 +4297,7 @@ void bdrv_img_create(const char *filename, const char *fmt,
if (backing_fmt) { if (backing_fmt) {
backing_options = qdict_new(); backing_options = qdict_new();
qdict_put(backing_options, "driver", qdict_put_str(backing_options, "driver", backing_fmt);
qstring_from_str(backing_fmt));
} }
bs = bdrv_open(full_backing, NULL, backing_options, back_flags, bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
@ -4712,11 +4702,9 @@ void bdrv_refresh_filename(BlockDriverState *bs)
* contain a representation of the filename, therefore the following * contain a representation of the filename, therefore the following
* suffices without querying the (exact_)filename of this BDS. */ * suffices without querying the (exact_)filename of this BDS. */
if (bs->file->bs->full_open_options) { if (bs->file->bs->full_open_options) {
qdict_put_obj(opts, "driver", qdict_put_str(opts, "driver", drv->format_name);
QOBJECT(qstring_from_str(drv->format_name)));
QINCREF(bs->file->bs->full_open_options); QINCREF(bs->file->bs->full_open_options);
qdict_put_obj(opts, "file", qdict_put(opts, "file", bs->file->bs->full_open_options);
QOBJECT(bs->file->bs->full_open_options));
bs->full_open_options = opts; bs->full_open_options = opts;
} else { } else {
@ -4732,8 +4720,7 @@ void bdrv_refresh_filename(BlockDriverState *bs)
opts = qdict_new(); opts = qdict_new();
append_open_options(opts, bs); append_open_options(opts, bs);
qdict_put_obj(opts, "driver", qdict_put_str(opts, "driver", drv->format_name);
QOBJECT(qstring_from_str(drv->format_name)));
if (bs->exact_filename[0]) { if (bs->exact_filename[0]) {
/* This may not work for all block protocol drivers (some may /* This may not work for all block protocol drivers (some may
@ -4743,8 +4730,7 @@ void bdrv_refresh_filename(BlockDriverState *bs)
* needs some special format of the options QDict, it needs to * needs some special format of the options QDict, it needs to
* implement the driver-specific bdrv_refresh_filename() function. * implement the driver-specific bdrv_refresh_filename() function.
*/ */
qdict_put_obj(opts, "filename", qdict_put_str(opts, "filename", bs->exact_filename);
QOBJECT(qstring_from_str(bs->exact_filename)));
} }
bs->full_open_options = opts; bs->full_open_options = opts;

8
block/blkdebug.c
View File

@ -301,7 +301,7 @@ static void blkdebug_parse_filename(const char *filename, QDict *options,
if (!strstart(filename, "blkdebug:", &filename)) { if (!strstart(filename, "blkdebug:", &filename)) {
/* There was no prefix; therefore, all options have to be already /* There was no prefix; therefore, all options have to be already
present in the QDict (except for the filename) */ present in the QDict (except for the filename) */
qdict_put(options, "x-image", qstring_from_str(filename)); qdict_put_str(options, "x-image", filename);
return; return;
} }
@ -320,7 +320,7 @@ static void blkdebug_parse_filename(const char *filename, QDict *options,
/* TODO Allow multi-level nesting and set file.filename here */ /* TODO Allow multi-level nesting and set file.filename here */
filename = c + 1; filename = c + 1;
qdict_put(options, "x-image", qstring_from_str(filename)); qdict_put_str(options, "x-image", filename);
} }
static QemuOptsList runtime_opts = { static QemuOptsList runtime_opts = {
@ -693,10 +693,10 @@ static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
} }
opts = qdict_new(); opts = qdict_new();
qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkdebug"))); qdict_put_str(opts, "driver", "blkdebug");
QINCREF(bs->file->bs->full_open_options); QINCREF(bs->file->bs->full_open_options);
qdict_put_obj(opts, "image", QOBJECT(bs->file->bs->full_open_options)); qdict_put(opts, "image", bs->file->bs->full_open_options);
for (e = qdict_first(options); e; e = qdict_next(options, e)) { for (e = qdict_first(options); e; e = qdict_next(options, e)) {
if (strcmp(qdict_entry_key(e), "x-image")) { if (strcmp(qdict_entry_key(e), "x-image")) {

11
block/blkverify.c
View File

@ -67,7 +67,7 @@ static void blkverify_parse_filename(const char *filename, QDict *options,
if (!strstart(filename, "blkverify:", &filename)) { if (!strstart(filename, "blkverify:", &filename)) {
/* There was no prefix; therefore, all options have to be already /* There was no prefix; therefore, all options have to be already
present in the QDict (except for the filename) */ present in the QDict (except for the filename) */
qdict_put(options, "x-image", qstring_from_str(filename)); qdict_put_str(options, "x-image", filename);
return; return;
} }
@ -84,7 +84,7 @@ static void blkverify_parse_filename(const char *filename, QDict *options,
/* TODO Allow multi-level nesting and set file.filename here */ /* TODO Allow multi-level nesting and set file.filename here */
filename = c + 1; filename = c + 1;
qdict_put(options, "x-image", qstring_from_str(filename)); qdict_put_str(options, "x-image", filename);
} }
static QemuOptsList runtime_opts = { static QemuOptsList runtime_opts = {
@ -288,13 +288,12 @@ static void blkverify_refresh_filename(BlockDriverState *bs, QDict *options)
&& s->test_file->bs->full_open_options) && s->test_file->bs->full_open_options)
{ {
QDict *opts = qdict_new(); QDict *opts = qdict_new();
qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkverify"))); qdict_put_str(opts, "driver", "blkverify");
QINCREF(bs->file->bs->full_open_options); QINCREF(bs->file->bs->full_open_options);
qdict_put_obj(opts, "raw", QOBJECT(bs->file->bs->full_open_options)); qdict_put(opts, "raw", bs->file->bs->full_open_options);
QINCREF(s->test_file->bs->full_open_options); QINCREF(s->test_file->bs->full_open_options);
qdict_put_obj(opts, "test", qdict_put(opts, "test", s->test_file->bs->full_open_options);
QOBJECT(s->test_file->bs->full_open_options));
bs->full_open_options = opts; bs->full_open_options = opts;
} }

2
block/curl.c
View File

@ -548,7 +548,7 @@ static void curl_clean_state(CURLState *s)
static void curl_parse_filename(const char *filename, QDict *options, static void curl_parse_filename(const char *filename, QDict *options,
Error **errp) Error **errp)
{ {
qdict_put(options, CURL_BLOCK_OPT_URL, qstring_from_str(filename)); qdict_put_str(options, CURL_BLOCK_OPT_URL, filename);
} }
static void curl_detach_aio_context(BlockDriverState *bs) static void curl_detach_aio_context(BlockDriverState *bs)

8
block/file-posix.c
View File

@ -375,7 +375,7 @@ static void raw_parse_filename(const char *filename, QDict *options,
* function call can be ignored. */ * function call can be ignored. */
strstart(filename, "file:", &filename); strstart(filename, "file:", &filename);
qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename))); qdict_put_str(options, "filename", filename);
} }
static QemuOptsList raw_runtime_opts = { static QemuOptsList raw_runtime_opts = {
@ -2155,7 +2155,7 @@ static void hdev_parse_filename(const char *filename, QDict *options,
/* The prefix is optional, just as for "file". */ /* The prefix is optional, just as for "file". */
strstart(filename, "host_device:", &filename); strstart(filename, "host_device:", &filename);
qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename))); qdict_put_str(options, "filename", filename);
} }
static bool hdev_is_sg(BlockDriverState *bs) static bool hdev_is_sg(BlockDriverState *bs)
@ -2244,7 +2244,7 @@ static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
goto hdev_open_Mac_error; goto hdev_open_Mac_error;
} }
qdict_put(options, "filename", qstring_from_str(bsd_path)); qdict_put_str(options, "filename", bsd_path);
hdev_open_Mac_error: hdev_open_Mac_error:
g_free(mediaType); g_free(mediaType);
@ -2454,7 +2454,7 @@ static void cdrom_parse_filename(const char *filename, QDict *options,
/* The prefix is optional, just as for "file". */ /* The prefix is optional, just as for "file". */
strstart(filename, "host_cdrom:", &filename); strstart(filename, "host_cdrom:", &filename);
qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename))); qdict_put_str(options, "filename", filename);
} }
#endif #endif

4
block/file-win32.c
View File

@ -281,7 +281,7 @@ static void raw_parse_filename(const char *filename, QDict *options,
* function call can be ignored. */ * function call can be ignored. */
strstart(filename, "file:", &filename); strstart(filename, "file:", &filename);
qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename))); qdict_put_str(options, "filename", filename);
} }
static QemuOptsList raw_runtime_opts = { static QemuOptsList raw_runtime_opts = {
@ -668,7 +668,7 @@ static void hdev_parse_filename(const char *filename, QDict *options,
/* The prefix is optional, just as for "file". */ /* The prefix is optional, just as for "file". */
strstart(filename, "host_device:", &filename); strstart(filename, "host_device:", &filename);
qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename))); qdict_put_str(options, "filename", filename);
} }
static int hdev_open(BlockDriverState *bs, QDict *options, int flags, static int hdev_open(BlockDriverState *bs, QDict *options, int flags,

48
block/gluster.c
View File

@ -321,7 +321,7 @@ static int parse_volume_options(BlockdevOptionsGluster *gconf, char *path)
static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf, static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf,
const char *filename) const char *filename)
{ {
SocketAddressFlat *gsconf; SocketAddress *gsconf;
URI *uri; URI *uri;
QueryParams *qp = NULL; QueryParams *qp = NULL;
bool is_unix = false; bool is_unix = false;
@ -332,19 +332,19 @@ static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf,
return -EINVAL; return -EINVAL;
} }
gconf->server = g_new0(SocketAddressFlatList, 1); gconf->server = g_new0(SocketAddressList, 1);
gconf->server->value = gsconf = g_new0(SocketAddressFlat, 1); gconf->server->value = gsconf = g_new0(SocketAddress, 1);
/* transport */ /* transport */
if (!uri->scheme || !strcmp(uri->scheme, "gluster")) { if (!uri->scheme || !strcmp(uri->scheme, "gluster")) {
gsconf->type = SOCKET_ADDRESS_FLAT_TYPE_INET; gsconf->type = SOCKET_ADDRESS_TYPE_INET;
} else if (!strcmp(uri->scheme, "gluster+tcp")) { } else if (!strcmp(uri->scheme, "gluster+tcp")) {
gsconf->type = SOCKET_ADDRESS_FLAT_TYPE_INET; gsconf->type = SOCKET_ADDRESS_TYPE_INET;
} else if (!strcmp(uri->scheme, "gluster+unix")) { } else if (!strcmp(uri->scheme, "gluster+unix")) {
gsconf->type = SOCKET_ADDRESS_FLAT_TYPE_UNIX; gsconf->type = SOCKET_ADDRESS_TYPE_UNIX;
is_unix = true; is_unix = true;
} else if (!strcmp(uri->scheme, "gluster+rdma")) { } else if (!strcmp(uri->scheme, "gluster+rdma")) {
gsconf->type = SOCKET_ADDRESS_FLAT_TYPE_INET; gsconf->type = SOCKET_ADDRESS_TYPE_INET;
error_report("Warning: rdma feature is not supported, falling " error_report("Warning: rdma feature is not supported, falling "
"back to tcp"); "back to tcp");
} else { } else {
@ -396,7 +396,7 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
struct glfs *glfs; struct glfs *glfs;
int ret; int ret;
int old_errno; int old_errno;
SocketAddressFlatList *server; SocketAddressList *server;
unsigned long long port; unsigned long long port;
glfs = glfs_find_preopened(gconf->volume); glfs = glfs_find_preopened(gconf->volume);
@ -413,11 +413,11 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
for (server = gconf->server; server; server = server->next) { for (server = gconf->server; server; server = server->next) {
switch (server->value->type) { switch (server->value->type) {
case SOCKET_ADDRESS_FLAT_TYPE_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
ret = glfs_set_volfile_server(glfs, "unix", ret = glfs_set_volfile_server(glfs, "unix",
server->value->u.q_unix.path, 0); server->value->u.q_unix.path, 0);
break; break;
case SOCKET_ADDRESS_FLAT_TYPE_INET: case SOCKET_ADDRESS_TYPE_INET:
if (parse_uint_full(server->value->u.inet.port, &port, 10) < 0 || if (parse_uint_full(server->value->u.inet.port, &port, 10) < 0 ||
port > 65535) { port > 65535) {
error_setg(errp, "'%s' is not a valid port number", error_setg(errp, "'%s' is not a valid port number",
@ -429,8 +429,8 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
server->value->u.inet.host, server->value->u.inet.host,
(int)port); (int)port);
break; break;
case SOCKET_ADDRESS_FLAT_TYPE_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
case SOCKET_ADDRESS_FLAT_TYPE_FD: case SOCKET_ADDRESS_TYPE_FD:
default: default:
abort(); abort();
} }
@ -450,7 +450,7 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
error_setg(errp, "Gluster connection for volume %s, path %s failed" error_setg(errp, "Gluster connection for volume %s, path %s failed"
" to connect", gconf->volume, gconf->path); " to connect", gconf->volume, gconf->path);
for (server = gconf->server; server; server = server->next) { for (server = gconf->server; server; server = server->next) {
if (server->value->type == SOCKET_ADDRESS_FLAT_TYPE_UNIX) { if (server->value->type == SOCKET_ADDRESS_TYPE_UNIX) {
error_append_hint(errp, "hint: failed on socket %s ", error_append_hint(errp, "hint: failed on socket %s ",
server->value->u.q_unix.path); server->value->u.q_unix.path);
} else { } else {
@ -487,8 +487,8 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
QDict *options, Error **errp) QDict *options, Error **errp)
{ {
QemuOpts *opts; QemuOpts *opts;
SocketAddressFlat *gsconf = NULL; SocketAddress *gsconf = NULL;
SocketAddressFlatList *curr = NULL; SocketAddressList *curr = NULL;
QDict *backing_options = NULL; QDict *backing_options = NULL;
Error *local_err = NULL; Error *local_err = NULL;
char *str = NULL; char *str = NULL;
@ -542,14 +542,14 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
goto out; goto out;
} }
gsconf = g_new0(SocketAddressFlat, 1); gsconf = g_new0(SocketAddress, 1);
if (!strcmp(ptr, "tcp")) { if (!strcmp(ptr, "tcp")) {
ptr = "inet"; /* accept legacy "tcp" */ ptr = "inet"; /* accept legacy "tcp" */
} }
type = qapi_enum_parse(SocketAddressFlatType_lookup, ptr, type = qapi_enum_parse(SocketAddressType_lookup, ptr,
SOCKET_ADDRESS_FLAT_TYPE__MAX, -1, NULL); SOCKET_ADDRESS_TYPE__MAX, -1, NULL);
if (type != SOCKET_ADDRESS_FLAT_TYPE_INET if (type != SOCKET_ADDRESS_TYPE_INET
&& type != SOCKET_ADDRESS_FLAT_TYPE_UNIX) { && type != SOCKET_ADDRESS_TYPE_UNIX) {
error_setg(&local_err, error_setg(&local_err,
"Parameter '%s' may be 'inet' or 'unix'", "Parameter '%s' may be 'inet' or 'unix'",
GLUSTER_OPT_TYPE); GLUSTER_OPT_TYPE);
@ -559,7 +559,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
gsconf->type = type; gsconf->type = type;
qemu_opts_del(opts); qemu_opts_del(opts);
if (gsconf->type == SOCKET_ADDRESS_FLAT_TYPE_INET) { if (gsconf->type == SOCKET_ADDRESS_TYPE_INET) {
/* create opts info from runtime_inet_opts list */ /* create opts info from runtime_inet_opts list */
opts = qemu_opts_create(&runtime_inet_opts, NULL, 0, &error_abort); opts = qemu_opts_create(&runtime_inet_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, backing_options, &local_err); qemu_opts_absorb_qdict(opts, backing_options, &local_err);
@ -628,11 +628,11 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
} }
if (gconf->server == NULL) { if (gconf->server == NULL) {
gconf->server = g_new0(SocketAddressFlatList, 1); gconf->server = g_new0(SocketAddressList, 1);
gconf->server->value = gsconf; gconf->server->value = gsconf;
curr = gconf->server; curr = gconf->server;
} else { } else {
curr->next = g_new0(SocketAddressFlatList, 1); curr->next = g_new0(SocketAddressList, 1);
curr->next->value = gsconf; curr->next->value = gsconf;
curr = curr->next; curr = curr->next;
} }
@ -648,7 +648,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
out: out:
error_propagate(errp, local_err); error_propagate(errp, local_err);
qapi_free_SocketAddressFlat(gsconf); qapi_free_SocketAddress(gsconf);
qemu_opts_del(opts); qemu_opts_del(opts);
g_free(str); g_free(str);
QDECREF(backing_options); QDECREF(backing_options);

75
block/nbd.c
View File

@ -47,7 +47,7 @@ typedef struct BDRVNBDState {
NBDClientSession client; NBDClientSession client;
/* For nbd_refresh_filename() */ /* For nbd_refresh_filename() */
SocketAddressFlat *saddr; SocketAddress *saddr;
char *export, *tlscredsid; char *export, *tlscredsid;
} BDRVNBDState; } BDRVNBDState;
@ -79,7 +79,7 @@ static int nbd_parse_uri(const char *filename, QDict *options)
p = uri->path ? uri->path : "/"; p = uri->path ? uri->path : "/";
p += strspn(p, "/"); p += strspn(p, "/");
if (p[0]) { if (p[0]) {
qdict_put(options, "export", qstring_from_str(p)); qdict_put_str(options, "export", p);
} }
qp = query_params_parse(uri->query); qp = query_params_parse(uri->query);
@ -94,9 +94,8 @@ static int nbd_parse_uri(const char *filename, QDict *options)
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
qdict_put(options, "server.type", qstring_from_str("unix")); qdict_put_str(options, "server.type", "unix");
qdict_put(options, "server.path", qdict_put_str(options, "server.path", qp->p[0].value);
qstring_from_str(qp->p[0].value));
} else { } else {
QString *host; QString *host;
char *port_str; char *port_str;
@ -115,11 +114,11 @@ static int nbd_parse_uri(const char *filename, QDict *options)
host = qstring_from_str(uri->server); host = qstring_from_str(uri->server);
} }
qdict_put(options, "server.type", qstring_from_str("inet")); qdict_put_str(options, "server.type", "inet");
qdict_put(options, "server.host", host); qdict_put(options, "server.host", host);
port_str = g_strdup_printf("%d", uri->port ?: NBD_DEFAULT_PORT); port_str = g_strdup_printf("%d", uri->port ?: NBD_DEFAULT_PORT);
qdict_put(options, "server.port", qstring_from_str(port_str)); qdict_put_str(options, "server.port", port_str);
g_free(port_str); g_free(port_str);
} }
@ -181,7 +180,7 @@ static void nbd_parse_filename(const char *filename, QDict *options,
export_name[0] = 0; /* truncate 'file' */ export_name[0] = 0; /* truncate 'file' */
export_name += strlen(EN_OPTSTR); export_name += strlen(EN_OPTSTR);
qdict_put(options, "export", qstring_from_str(export_name)); qdict_put_str(options, "export", export_name);
} }
/* extract the host_spec - fail if it's not nbd:... */ /* extract the host_spec - fail if it's not nbd:... */
@ -196,19 +195,19 @@ static void nbd_parse_filename(const char *filename, QDict *options,
/* are we a UNIX or TCP socket? */ /* are we a UNIX or TCP socket? */
if (strstart(host_spec, "unix:", &unixpath)) { if (strstart(host_spec, "unix:", &unixpath)) {
qdict_put(options, "server.type", qstring_from_str("unix")); qdict_put_str(options, "server.type", "unix");
qdict_put(options, "server.path", qstring_from_str(unixpath)); qdict_put_str(options, "server.path", unixpath);
} else { } else {
InetSocketAddress *addr = NULL; InetSocketAddress *addr = g_new(InetSocketAddress, 1);
addr = inet_parse(host_spec, errp); if (inet_parse(addr, host_spec, errp)) {
if (!addr) { goto out_inet;
goto out;
} }
qdict_put(options, "server.type", qstring_from_str("inet")); qdict_put_str(options, "server.type", "inet");
qdict_put(options, "server.host", qstring_from_str(addr->host)); qdict_put_str(options, "server.host", addr->host);
qdict_put(options, "server.port", qstring_from_str(addr->port)); qdict_put_str(options, "server.port", addr->port);
out_inet:
qapi_free_InetSocketAddress(addr); qapi_free_InetSocketAddress(addr);
} }
@ -247,22 +246,22 @@ static bool nbd_process_legacy_socket_options(QDict *output_options,
return false; return false;
} }
qdict_put(output_options, "server.type", qstring_from_str("unix")); qdict_put_str(output_options, "server.type", "unix");
qdict_put(output_options, "server.path", qstring_from_str(path)); qdict_put_str(output_options, "server.path", path);
} else if (host) { } else if (host) {
qdict_put(output_options, "server.type", qstring_from_str("inet")); qdict_put_str(output_options, "server.type", "inet");
qdict_put(output_options, "server.host", qstring_from_str(host)); qdict_put_str(output_options, "server.host", host);
qdict_put(output_options, "server.port", qdict_put_str(output_options, "server.port",
qstring_from_str(port ?: stringify(NBD_DEFAULT_PORT))); port ?: stringify(NBD_DEFAULT_PORT));
} }
return true; return true;
} }
static SocketAddressFlat *nbd_config(BDRVNBDState *s, QDict *options, static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
Error **errp) Error **errp)
{ {
SocketAddressFlat *saddr = NULL; SocketAddress *saddr = NULL;
QDict *addr = NULL; QDict *addr = NULL;
QObject *crumpled_addr = NULL; QObject *crumpled_addr = NULL;
Visitor *iv = NULL; Visitor *iv = NULL;
@ -288,7 +287,7 @@ static SocketAddressFlat *nbd_config(BDRVNBDState *s, QDict *options,
* visitor expects the former. * visitor expects the former.
*/ */
iv = qobject_input_visitor_new(crumpled_addr); iv = qobject_input_visitor_new(crumpled_addr);
visit_type_SocketAddressFlat(iv, NULL, &saddr, &local_err); visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
goto done; goto done;
@ -307,10 +306,9 @@ NBDClientSession *nbd_get_client_session(BlockDriverState *bs)
return &s->client; return &s->client;
} }
static QIOChannelSocket *nbd_establish_connection(SocketAddressFlat *saddr_flat, static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr,
Error **errp) Error **errp)
{ {
SocketAddress *saddr = socket_address_crumple(saddr_flat);
QIOChannelSocket *sioc; QIOChannelSocket *sioc;
Error *local_err = NULL; Error *local_err = NULL;
@ -320,7 +318,6 @@ static QIOChannelSocket *nbd_establish_connection(SocketAddressFlat *saddr_flat,
qio_channel_socket_connect_sync(sioc, qio_channel_socket_connect_sync(sioc,
saddr, saddr,
&local_err); &local_err);
qapi_free_SocketAddress(saddr);
if (local_err) { if (local_err) {
object_unref(OBJECT(sioc)); object_unref(OBJECT(sioc));
error_propagate(errp, local_err); error_propagate(errp, local_err);
@ -413,7 +410,7 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,
goto error; goto error;
} }
/* Translate @host, @port, and @path to a SocketAddressFlat */ /* Translate @host, @port, and @path to a SocketAddress */
if (!nbd_process_legacy_socket_options(options, opts, errp)) { if (!nbd_process_legacy_socket_options(options, opts, errp)) {
goto error; goto error;
} }
@ -434,7 +431,7 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,
} }
/* TODO SOCKET_ADDRESS_KIND_FD where fd has AF_INET or AF_INET6 */ /* TODO SOCKET_ADDRESS_KIND_FD where fd has AF_INET or AF_INET6 */
if (s->saddr->type != SOCKET_ADDRESS_FLAT_TYPE_INET) { if (s->saddr->type != SOCKET_ADDRESS_TYPE_INET) {
error_setg(errp, "TLS only supported over IP sockets"); error_setg(errp, "TLS only supported over IP sockets");
goto error; goto error;
} }
@ -461,7 +458,7 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,
object_unref(OBJECT(tlscreds)); object_unref(OBJECT(tlscreds));
} }
if (ret < 0) { if (ret < 0) {
qapi_free_SocketAddressFlat(s->saddr); qapi_free_SocketAddress(s->saddr);
g_free(s->export); g_free(s->export);
g_free(s->tlscredsid); g_free(s->tlscredsid);
} }
@ -487,7 +484,7 @@ static void nbd_close(BlockDriverState *bs)
nbd_client_close(bs); nbd_client_close(bs);
qapi_free_SocketAddressFlat(s->saddr); qapi_free_SocketAddress(s->saddr);
g_free(s->export); g_free(s->export);
g_free(s->tlscredsid); g_free(s->tlscredsid);
} }
@ -518,17 +515,17 @@ static void nbd_refresh_filename(BlockDriverState *bs, QDict *options)
Visitor *ov; Visitor *ov;
const char *host = NULL, *port = NULL, *path = NULL; const char *host = NULL, *port = NULL, *path = NULL;
if (s->saddr->type == SOCKET_ADDRESS_FLAT_TYPE_INET) { if (s->saddr->type == SOCKET_ADDRESS_TYPE_INET) {
const InetSocketAddress *inet = &s->saddr->u.inet; const InetSocketAddress *inet = &s->saddr->u.inet;
if (!inet->has_ipv4 && !inet->has_ipv6 && !inet->has_to) { if (!inet->has_ipv4 && !inet->has_ipv6 && !inet->has_to) {
host = inet->host; host = inet->host;
port = inet->port; port = inet->port;
} }
} else if (s->saddr->type == SOCKET_ADDRESS_FLAT_TYPE_UNIX) { } else if (s->saddr->type == SOCKET_ADDRESS_TYPE_UNIX) {
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(opts, "driver", qstring_from_str("nbd")); 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),
@ -545,16 +542,16 @@ static void nbd_refresh_filename(BlockDriverState *bs, QDict *options)
} }
ov = qobject_output_visitor_new(&saddr_qdict); ov = qobject_output_visitor_new(&saddr_qdict);
visit_type_SocketAddressFlat(ov, NULL, &s->saddr, &error_abort); visit_type_SocketAddress(ov, NULL, &s->saddr, &error_abort);
visit_complete(ov, &saddr_qdict); visit_complete(ov, &saddr_qdict);
visit_free(ov); visit_free(ov);
qdict_put_obj(opts, "server", saddr_qdict); qdict_put_obj(opts, "server", saddr_qdict);
if (s->export) { if (s->export) {
qdict_put(opts, "export", qstring_from_str(s->export)); qdict_put_str(opts, "export", s->export);
} }
if (s->tlscredsid) { if (s->tlscredsid) {
qdict_put(opts, "tls-creds", qstring_from_str(s->tlscredsid)); qdict_put_str(opts, "tls-creds", s->tlscredsid);
} }
qdict_flatten(opts); qdict_flatten(opts);

43
block/nfs.c
View File

@ -104,9 +104,9 @@ static int nfs_parse_uri(const char *filename, QDict *options, Error **errp)
goto out; goto out;
} }
qdict_put(options, "server.host", qstring_from_str(uri->server)); qdict_put_str(options, "server.host", uri->server);
qdict_put(options, "server.type", qstring_from_str("inet")); qdict_put_str(options, "server.type", "inet");
qdict_put(options, "path", qstring_from_str(uri->path)); qdict_put_str(options, "path", uri->path);
for (i = 0; i < qp->n; i++) { for (i = 0; i < qp->n; i++) {
unsigned long long val; unsigned long long val;
@ -121,23 +121,17 @@ static int nfs_parse_uri(const char *filename, QDict *options, Error **errp)
goto out; goto out;
} }
if (!strcmp(qp->p[i].name, "uid")) { if (!strcmp(qp->p[i].name, "uid")) {
qdict_put(options, "user", qdict_put_str(options, "user", qp->p[i].value);
qstring_from_str(qp->p[i].value));
} else if (!strcmp(qp->p[i].name, "gid")) { } else if (!strcmp(qp->p[i].name, "gid")) {
qdict_put(options, "group", qdict_put_str(options, "group", qp->p[i].value);
qstring_from_str(qp->p[i].value));
} else if (!strcmp(qp->p[i].name, "tcp-syncnt")) { } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) {
qdict_put(options, "tcp-syn-count", qdict_put_str(options, "tcp-syn-count", qp->p[i].value);
qstring_from_str(qp->p[i].value));
} else if (!strcmp(qp->p[i].name, "readahead")) { } else if (!strcmp(qp->p[i].name, "readahead")) {
qdict_put(options, "readahead-size", qdict_put_str(options, "readahead-size", qp->p[i].value);
qstring_from_str(qp->p[i].value));
} else if (!strcmp(qp->p[i].name, "pagecache")) { } else if (!strcmp(qp->p[i].name, "pagecache")) {
qdict_put(options, "page-cache-size", qdict_put_str(options, "page-cache-size", qp->p[i].value);
qstring_from_str(qp->p[i].value));
} else if (!strcmp(qp->p[i].name, "debug")) { } else if (!strcmp(qp->p[i].name, "debug")) {
qdict_put(options, "debug", qdict_put_str(options, "debug", qp->p[i].value);
qstring_from_str(qp->p[i].value));
} else { } else {
error_setg(errp, "Unknown NFS parameter name: %s", error_setg(errp, "Unknown NFS parameter name: %s",
qp->p[i].name); qp->p[i].name);
@ -819,7 +813,7 @@ static void nfs_refresh_filename(BlockDriverState *bs, QDict *options)
QObject *server_qdict; QObject *server_qdict;
Visitor *ov; Visitor *ov;
qdict_put(opts, "driver", qstring_from_str("nfs")); 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),
@ -842,28 +836,25 @@ static void nfs_refresh_filename(BlockDriverState *bs, QDict *options)
visit_type_NFSServer(ov, NULL, &client->server, &error_abort); visit_type_NFSServer(ov, NULL, &client->server, &error_abort);
visit_complete(ov, &server_qdict); visit_complete(ov, &server_qdict);
qdict_put_obj(opts, "server", server_qdict); qdict_put_obj(opts, "server", server_qdict);
qdict_put(opts, "path", qstring_from_str(client->path)); qdict_put_str(opts, "path", client->path);
if (client->uid) { if (client->uid) {
qdict_put(opts, "user", qint_from_int(client->uid)); qdict_put_int(opts, "user", client->uid);
} }
if (client->gid) { if (client->gid) {
qdict_put(opts, "group", qint_from_int(client->gid)); qdict_put_int(opts, "group", client->gid);
} }
if (client->tcp_syncnt) { if (client->tcp_syncnt) {
qdict_put(opts, "tcp-syn-cnt", qdict_put_int(opts, "tcp-syn-cnt", client->tcp_syncnt);
qint_from_int(client->tcp_syncnt));
} }
if (client->readahead) { if (client->readahead) {
qdict_put(opts, "readahead-size", qdict_put_int(opts, "readahead-size", client->readahead);
qint_from_int(client->readahead));
} }
if (client->pagecache) { if (client->pagecache) {
qdict_put(opts, "page-cache-size", qdict_put_int(opts, "page-cache-size", client->pagecache);
qint_from_int(client->pagecache));
} }
if (client->debug) { if (client->debug) {
qdict_put(opts, "debug", qint_from_int(client->debug)); qdict_put_int(opts, "debug", client->debug);
} }
visit_free(ov); visit_free(ov);

2
block/null.c
View File

@ -232,7 +232,7 @@ static void null_refresh_filename(BlockDriverState *bs, QDict *opts)
bs->drv->format_name); bs->drv->format_name);
} }
qdict_put(opts, "driver", qstring_from_str(bs->drv->format_name)); qdict_put_str(opts, "driver", bs->drv->format_name);
bs->full_open_options = opts; bs->full_open_options = opts;
} }

4
block/qcow2.c
View File

@ -2265,7 +2265,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,
* table) * table)
*/ */
options = qdict_new(); options = qdict_new();
qdict_put(options, "driver", qstring_from_str("qcow2")); qdict_put_str(options, "driver", "qcow2");
blk = blk_new_open(filename, NULL, options, blk = blk_new_open(filename, NULL, options,
BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH, BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
&local_err); &local_err);
@ -2327,7 +2327,7 @@ static int qcow2_create2(const char *filename, int64_t total_size,
/* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */ /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */
options = qdict_new(); options = qdict_new();
qdict_put(options, "driver", qstring_from_str("qcow2")); qdict_put_str(options, "driver", "qcow2");
blk = blk_new_open(filename, NULL, options, blk = blk_new_open(filename, NULL, options,
BDRV_O_RDWR | BDRV_O_NO_BACKING, &local_err); BDRV_O_RDWR | BDRV_O_NO_BACKING, &local_err);
if (blk == NULL) { if (blk == NULL) {

16
block/quorum.c
View File

@ -1096,19 +1096,15 @@ static void quorum_refresh_filename(BlockDriverState *bs, QDict *options)
children = qlist_new(); children = qlist_new();
for (i = 0; i < s->num_children; i++) { for (i = 0; i < s->num_children; i++) {
QINCREF(s->children[i]->bs->full_open_options); QINCREF(s->children[i]->bs->full_open_options);
qlist_append_obj(children, qlist_append(children, s->children[i]->bs->full_open_options);
QOBJECT(s->children[i]->bs->full_open_options));
} }
opts = qdict_new(); opts = qdict_new();
qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("quorum"))); qdict_put_str(opts, "driver", "quorum");
qdict_put_obj(opts, QUORUM_OPT_VOTE_THRESHOLD, qdict_put_int(opts, QUORUM_OPT_VOTE_THRESHOLD, s->threshold);
QOBJECT(qint_from_int(s->threshold))); qdict_put_bool(opts, QUORUM_OPT_BLKVERIFY, s->is_blkverify);
qdict_put_obj(opts, QUORUM_OPT_BLKVERIFY, qdict_put_bool(opts, QUORUM_OPT_REWRITE, s->rewrite_corrupted);
QOBJECT(qbool_from_bool(s->is_blkverify))); qdict_put(opts, "children", children);
qdict_put_obj(opts, QUORUM_OPT_REWRITE,
QOBJECT(qbool_from_bool(s->rewrite_corrupted)));
qdict_put_obj(opts, "children", QOBJECT(children));
bs->full_open_options = opts; bs->full_open_options = opts;
} }

16
block/rbd.c
View File

@ -154,20 +154,20 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
goto done; goto done;
} }
qemu_rbd_unescape(found_str); qemu_rbd_unescape(found_str);
qdict_put(options, "pool", qstring_from_str(found_str)); qdict_put_str(options, "pool", found_str);
if (strchr(p, '@')) { if (strchr(p, '@')) {
found_str = qemu_rbd_next_tok(p, '@', &p); found_str = qemu_rbd_next_tok(p, '@', &p);
qemu_rbd_unescape(found_str); qemu_rbd_unescape(found_str);
qdict_put(options, "image", qstring_from_str(found_str)); qdict_put_str(options, "image", found_str);
found_str = qemu_rbd_next_tok(p, ':', &p); found_str = qemu_rbd_next_tok(p, ':', &p);
qemu_rbd_unescape(found_str); qemu_rbd_unescape(found_str);
qdict_put(options, "snapshot", qstring_from_str(found_str)); qdict_put_str(options, "snapshot", found_str);
} else { } else {
found_str = qemu_rbd_next_tok(p, ':', &p); found_str = qemu_rbd_next_tok(p, ':', &p);
qemu_rbd_unescape(found_str); qemu_rbd_unescape(found_str);
qdict_put(options, "image", qstring_from_str(found_str)); qdict_put_str(options, "image", found_str);
} }
if (!p) { if (!p) {
goto done; goto done;
@ -189,9 +189,9 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
qemu_rbd_unescape(value); qemu_rbd_unescape(value);
if (!strcmp(name, "conf")) { if (!strcmp(name, "conf")) {
qdict_put(options, "conf", qstring_from_str(value)); qdict_put_str(options, "conf", value);
} else if (!strcmp(name, "id")) { } else if (!strcmp(name, "id")) {
qdict_put(options, "user" , qstring_from_str(value)); qdict_put_str(options, "user", value);
} else { } else {
/* /*
* We pass these internally to qemu_rbd_set_keypairs(), so * We pass these internally to qemu_rbd_set_keypairs(), so
@ -204,8 +204,8 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
if (!keypairs) { if (!keypairs) {
keypairs = qlist_new(); keypairs = qlist_new();
} }
qlist_append(keypairs, qstring_from_str(name)); qlist_append_str(keypairs, name);
qlist_append(keypairs, qstring_from_str(value)); qlist_append_str(keypairs, value);
} }
} }

20
block/sheepdog.c
View File

@ -536,14 +536,12 @@ static SocketAddress *sd_socket_address(const char *path,
SocketAddress *addr = g_new0(SocketAddress, 1); SocketAddress *addr = g_new0(SocketAddress, 1);
if (path) { if (path) {
addr->type = SOCKET_ADDRESS_KIND_UNIX; addr->type = SOCKET_ADDRESS_TYPE_UNIX;
addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); addr->u.q_unix.path = g_strdup(path);
addr->u.q_unix.data->path = g_strdup(path);
} else { } else {
addr->type = SOCKET_ADDRESS_KIND_INET; addr->type = SOCKET_ADDRESS_TYPE_INET;
addr->u.inet.data = g_new0(InetSocketAddress, 1); addr->u.inet.host = g_strdup(host ?: SD_DEFAULT_ADDR);
addr->u.inet.data->host = g_strdup(host ?: SD_DEFAULT_ADDR); addr->u.inet.port = g_strdup(port ?: stringify(SD_DEFAULT_PORT));
addr->u.inet.data->port = g_strdup(port ?: stringify(SD_DEFAULT_PORT));
} }
return addr; return addr;
@ -554,7 +552,6 @@ static SocketAddress *sd_server_config(QDict *options, Error **errp)
QDict *server = NULL; QDict *server = NULL;
QObject *crumpled_server = NULL; QObject *crumpled_server = NULL;
Visitor *iv = NULL; Visitor *iv = NULL;
SocketAddressFlat *saddr_flat = NULL;
SocketAddress *saddr = NULL; SocketAddress *saddr = NULL;
Error *local_err = NULL; Error *local_err = NULL;
@ -574,16 +571,13 @@ static SocketAddress *sd_server_config(QDict *options, Error **errp)
* visitor expects the former. * visitor expects the former.
*/ */
iv = qobject_input_visitor_new(crumpled_server); iv = qobject_input_visitor_new(crumpled_server);
visit_type_SocketAddressFlat(iv, NULL, &saddr_flat, &local_err); visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
goto done; goto done;
} }
saddr = socket_address_crumple(saddr_flat);
done: done:
qapi_free_SocketAddressFlat(saddr_flat);
visit_free(iv); visit_free(iv);
qobject_decref(crumpled_server); qobject_decref(crumpled_server);
QDECREF(server); QDECREF(server);
@ -597,7 +591,7 @@ static int connect_to_sdog(BDRVSheepdogState *s, Error **errp)
fd = socket_connect(s->addr, NULL, NULL, errp); fd = socket_connect(s->addr, NULL, NULL, errp);
if (s->addr->type == SOCKET_ADDRESS_KIND_INET && fd >= 0) { if (s->addr->type == SOCKET_ADDRESS_TYPE_INET && fd >= 0) {
int ret = socket_set_nodelay(fd); int ret = socket_set_nodelay(fd);
if (ret < 0) { if (ret < 0) {
error_report("%s", strerror(errno)); error_report("%s", strerror(errno));

2
block/snapshot.c
View File

@ -200,7 +200,7 @@ int bdrv_snapshot_goto(BlockDriverState *bs,
qdict_extract_subqdict(options, &file_options, "file."); qdict_extract_subqdict(options, &file_options, "file.");
QDECREF(file_options); QDECREF(file_options);
qdict_put(options, "file", qstring_from_str(bdrv_get_node_name(file))); qdict_put_str(options, "file", bdrv_get_node_name(file));
drv->bdrv_close(bs); drv->bdrv_close(bs);
bdrv_unref_child(bs, bs->file); bdrv_unref_child(bs, bs->file);

16
block/ssh.c
View File

@ -227,24 +227,23 @@ static int parse_uri(const char *filename, QDict *options, Error **errp)
} }
if(uri->user && strcmp(uri->user, "") != 0) { if(uri->user && strcmp(uri->user, "") != 0) {
qdict_put(options, "user", qstring_from_str(uri->user)); qdict_put_str(options, "user", uri->user);
} }
qdict_put(options, "server.host", qstring_from_str(uri->server)); qdict_put_str(options, "server.host", uri->server);
port_str = g_strdup_printf("%d", uri->port ?: 22); port_str = g_strdup_printf("%d", uri->port ?: 22);
qdict_put(options, "server.port", qstring_from_str(port_str)); qdict_put_str(options, "server.port", port_str);
g_free(port_str); g_free(port_str);
qdict_put(options, "path", qstring_from_str(uri->path)); qdict_put_str(options, "path", uri->path);
/* Pick out any query parameters that we understand, and ignore /* Pick out any query parameters that we understand, and ignore
* the rest. * the rest.
*/ */
for (i = 0; i < qp->n; ++i) { for (i = 0; i < qp->n; ++i) {
if (strcmp(qp->p[i].name, "host_key_check") == 0) { if (strcmp(qp->p[i].name, "host_key_check") == 0) {
qdict_put(options, "host_key_check", qdict_put_str(options, "host_key_check", qp->p[i].value);
qstring_from_str(qp->p[i].value));
} }
} }
@ -574,9 +573,8 @@ static bool ssh_process_legacy_socket_options(QDict *output_opts,
} }
if (host) { if (host) {
qdict_put(output_opts, "server.host", qstring_from_str(host)); qdict_put_str(output_opts, "server.host", host);
qdict_put(output_opts, "server.port", qdict_put_str(output_opts, "server.port", port ?: stringify(22));
qstring_from_str(port ?: stringify(22)));
} }
return true; return true;

10
block/vvfat.c
View File

@ -1057,10 +1057,10 @@ static void vvfat_parse_filename(const char *filename, QDict *options,
} }
/* Fill in the options QDict */ /* Fill in the options QDict */
qdict_put(options, "dir", qstring_from_str(filename)); qdict_put_str(options, "dir", filename);
qdict_put(options, "fat-type", qint_from_int(fat_type)); qdict_put_int(options, "fat-type", fat_type);
qdict_put(options, "floppy", qbool_from_bool(floppy)); qdict_put_bool(options, "floppy", floppy);
qdict_put(options, "rw", qbool_from_bool(rw)); qdict_put_bool(options, "rw", rw);
} }
static int vvfat_open(BlockDriverState *bs, QDict *options, int flags, static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
@ -3051,7 +3051,7 @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
} }
options = qdict_new(); options = qdict_new();
qdict_put(options, "write-target.driver", qstring_from_str("qcow")); qdict_put_str(options, "write-target.driver", "qcow");
s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs, s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
&child_vvfat_qcow, false, errp); &child_vvfat_qcow, false, errp);
QDECREF(options); QDECREF(options);

6
block/vxhs.c
View File

@ -182,15 +182,15 @@ static int vxhs_parse_uri(const char *filename, QDict *options)
return -EINVAL; return -EINVAL;
} }
qdict_put(options, VXHS_OPT_SERVER".host", qstring_from_str(uri->server)); qdict_put_str(options, VXHS_OPT_SERVER ".host", uri->server);
if (uri->port) { if (uri->port) {
port = g_strdup_printf("%d", uri->port); port = g_strdup_printf("%d", uri->port);
qdict_put(options, VXHS_OPT_SERVER".port", qstring_from_str(port)); qdict_put_str(options, VXHS_OPT_SERVER ".port", port);
g_free(port); g_free(port);
} }
qdict_put(options, "vdisk-id", qstring_from_str(uri->path)); qdict_put_str(options, "vdisk-id", uri->path);
trace_vxhs_parse_uri_hostinfo(uri->server, uri->port); trace_vxhs_parse_uri_hostinfo(uri->server, uri->port);
uri_free(uri); uri_free(uri);

19
blockdev-nbd.c
View File

@ -99,8 +99,7 @@ static QCryptoTLSCreds *nbd_get_tls_creds(const char *id, Error **errp)
} }
void qmp_nbd_server_start(SocketAddress *addr, void nbd_server_start(SocketAddress *addr, const char *tls_creds,
bool has_tls_creds, const char *tls_creds,
Error **errp) Error **errp)
{ {
if (nbd_server) { if (nbd_server) {
@ -118,14 +117,14 @@ void qmp_nbd_server_start(SocketAddress *addr,
goto error; goto error;
} }
if (has_tls_creds) { if (tls_creds) {
nbd_server->tlscreds = nbd_get_tls_creds(tls_creds, errp); nbd_server->tlscreds = nbd_get_tls_creds(tls_creds, errp);
if (!nbd_server->tlscreds) { if (!nbd_server->tlscreds) {
goto error; goto error;
} }
/* TODO SOCKET_ADDRESS_KIND_FD where fd has AF_INET or AF_INET6 */ /* TODO SOCKET_ADDRESS_TYPE_FD where fd has AF_INET or AF_INET6 */
if (addr->type != SOCKET_ADDRESS_KIND_INET) { if (addr->type != SOCKET_ADDRESS_TYPE_INET) {
error_setg(errp, "TLS is only supported with IPv4/IPv6"); error_setg(errp, "TLS is only supported with IPv4/IPv6");
goto error; goto error;
} }
@ -145,6 +144,16 @@ void qmp_nbd_server_start(SocketAddress *addr,
nbd_server = NULL; nbd_server = NULL;
} }
void qmp_nbd_server_start(SocketAddressLegacy *addr,
bool has_tls_creds, const char *tls_creds,
Error **errp)
{
SocketAddress *addr_flat = socket_address_flatten(addr);
nbd_server_start(addr_flat, tls_creds, errp);
qapi_free_SocketAddress(addr_flat);
}
void qmp_nbd_server_add(const char *device, bool has_writable, bool writable, void qmp_nbd_server_add(const char *device, bool has_writable, bool writable,
Error **errp) Error **errp)
{ {

30
blockdev.c
View File

@ -527,7 +527,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
error_setg(errp, "Cannot specify both 'driver' and 'format'"); error_setg(errp, "Cannot specify both 'driver' and 'format'");
goto early_err; goto early_err;
} }
qdict_put(bs_opts, "driver", qstring_from_str(buf)); qdict_put_str(bs_opts, "driver", buf);
} }
on_write_error = BLOCKDEV_ON_ERROR_ENOSPC; on_write_error = BLOCKDEV_ON_ERROR_ENOSPC;
@ -903,10 +903,8 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
copy_on_read = false; copy_on_read = false;
} }
qdict_put(bs_opts, BDRV_OPT_READ_ONLY, qdict_put_str(bs_opts, BDRV_OPT_READ_ONLY, read_only ? "on" : "off");
qstring_from_str(read_only ? "on" : "off")); qdict_put_str(bs_opts, "copy-on-read", copy_on_read ? "on" : "off");
qdict_put(bs_opts, "copy-on-read",
qstring_from_str(copy_on_read ? "on" :"off"));
/* Controller type */ /* Controller type */
value = qemu_opt_get(legacy_opts, "if"); value = qemu_opt_get(legacy_opts, "if");
@ -1030,7 +1028,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
new_id = g_strdup_printf("%s%s%i", if_name[type], new_id = g_strdup_printf("%s%s%i", if_name[type],
mediastr, unit_id); mediastr, unit_id);
} }
qdict_put(bs_opts, "id", qstring_from_str(new_id)); qdict_put_str(bs_opts, "id", new_id);
g_free(new_id); g_free(new_id);
} }
@ -1067,7 +1065,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
error_report("werror is not supported by this bus type"); error_report("werror is not supported by this bus type");
goto fail; goto fail;
} }
qdict_put(bs_opts, "werror", qstring_from_str(werror)); qdict_put_str(bs_opts, "werror", werror);
} }
rerror = qemu_opt_get(legacy_opts, "rerror"); rerror = qemu_opt_get(legacy_opts, "rerror");
@ -1077,7 +1075,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
error_report("rerror is not supported by this bus type"); error_report("rerror is not supported by this bus type");
goto fail; goto fail;
} }
qdict_put(bs_opts, "rerror", qstring_from_str(rerror)); qdict_put_str(bs_opts, "rerror", rerror);
} }
/* Actual block device init: Functionality shared with blockdev-add */ /* Actual block device init: Functionality shared with blockdev-add */
@ -1737,10 +1735,9 @@ static void external_snapshot_prepare(BlkActionState *common,
options = qdict_new(); options = qdict_new();
if (s->has_snapshot_node_name) { if (s->has_snapshot_node_name) {
qdict_put(options, "node-name", qdict_put_str(options, "node-name", snapshot_node_name);
qstring_from_str(snapshot_node_name));
} }
qdict_put(options, "driver", qstring_from_str(format)); qdict_put_str(options, "driver", format);
flags |= BDRV_O_NO_BACKING; flags |= BDRV_O_NO_BACKING;
} }
@ -2579,11 +2576,10 @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
options = qdict_new(); options = qdict_new();
detect_zeroes = blk_get_detect_zeroes_from_root_state(blk); detect_zeroes = blk_get_detect_zeroes_from_root_state(blk);
qdict_put(options, "detect-zeroes", qdict_put_str(options, "detect-zeroes", detect_zeroes ? "on" : "off");
qstring_from_str(detect_zeroes ? "on" : "off"));
if (has_format) { if (has_format) {
qdict_put(options, "driver", qstring_from_str(format)); qdict_put_str(options, "driver", format);
} }
medium_bs = bdrv_open(filename, NULL, options, bdrv_flags, errp); medium_bs = bdrv_open(filename, NULL, options, bdrv_flags, errp);
@ -3232,7 +3228,7 @@ static BlockJob *do_drive_backup(DriveBackup *backup, BlockJobTxn *txn,
if (backup->format) { if (backup->format) {
options = qdict_new(); options = qdict_new();
qdict_put(options, "driver", qstring_from_str(backup->format)); qdict_put_str(options, "driver", backup->format);
} }
target_bs = bdrv_open(backup->target, NULL, options, flags, errp); target_bs = bdrv_open(backup->target, NULL, options, flags, errp);
@ -3536,10 +3532,10 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
options = qdict_new(); options = qdict_new();
if (arg->has_node_name) { if (arg->has_node_name) {
qdict_put(options, "node-name", qstring_from_str(arg->node_name)); qdict_put_str(options, "node-name", arg->node_name);
} }
if (format) { if (format) {
qdict_put(options, "driver", qstring_from_str(format)); qdict_put_str(options, "driver", format);
} }
/* Mirroring takes care of copy-on-write using the source's backing /* Mirroring takes care of copy-on-write using the source's backing

36
chardev/char-socket.c
View File

@ -360,26 +360,26 @@ static char *SocketAddress_to_str(const char *prefix, SocketAddress *addr,
bool is_listen, bool is_telnet) bool is_listen, bool is_telnet)
{ {
switch (addr->type) { switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_TYPE_INET:
return g_strdup_printf("%s%s:%s:%s%s", prefix, return g_strdup_printf("%s%s:%s:%s%s", prefix,
is_telnet ? "telnet" : "tcp", is_telnet ? "telnet" : "tcp",
addr->u.inet.data->host, addr->u.inet.host,
addr->u.inet.data->port, addr->u.inet.port,
is_listen ? ",server" : ""); is_listen ? ",server" : "");
break; break;
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
return g_strdup_printf("%sunix:%s%s", prefix, return g_strdup_printf("%sunix:%s%s", prefix,
addr->u.q_unix.data->path, addr->u.q_unix.path,
is_listen ? ",server" : ""); is_listen ? ",server" : "");
break; break;
case SOCKET_ADDRESS_KIND_FD: case SOCKET_ADDRESS_TYPE_FD:
return g_strdup_printf("%sfd:%s%s", prefix, addr->u.fd.data->str, return g_strdup_printf("%sfd:%s%s", prefix, addr->u.fd.str,
is_listen ? ",server" : ""); is_listen ? ",server" : "");
break; break;
case SOCKET_ADDRESS_KIND_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
return g_strdup_printf("%svsock:%s:%s", prefix, return g_strdup_printf("%svsock:%s:%s", prefix,
addr->u.vsock.data->cid, addr->u.vsock.cid,
addr->u.vsock.data->port); addr->u.vsock.port);
default: default:
abort(); abort();
} }
@ -648,7 +648,7 @@ static void tcp_chr_tls_init(Chardev *chr)
} else { } else {
tioc = qio_channel_tls_new_client( tioc = qio_channel_tls_new_client(
s->ioc, s->tls_creds, s->ioc, s->tls_creds,
s->addr->u.inet.data->host, s->addr->u.inet.host,
&err); &err);
} }
if (tioc == NULL) { if (tioc == NULL) {
@ -859,7 +859,6 @@ static void qmp_chardev_open_socket(Chardev *chr,
{ {
SocketChardev *s = SOCKET_CHARDEV(chr); SocketChardev *s = SOCKET_CHARDEV(chr);
ChardevSocket *sock = backend->u.socket.data; ChardevSocket *sock = backend->u.socket.data;
SocketAddress *addr = sock->addr;
bool do_nodelay = sock->has_nodelay ? sock->nodelay : false; bool do_nodelay = sock->has_nodelay ? sock->nodelay : false;
bool is_listen = sock->has_server ? sock->server : true; bool is_listen = sock->has_server ? sock->server : true;
bool is_telnet = sock->has_telnet ? sock->telnet : false; bool is_telnet = sock->has_telnet ? sock->telnet : false;
@ -867,6 +866,7 @@ static void qmp_chardev_open_socket(Chardev *chr,
bool is_waitconnect = sock->has_wait ? sock->wait : false; bool is_waitconnect = sock->has_wait ? sock->wait : false;
int64_t reconnect = sock->has_reconnect ? sock->reconnect : 0; int64_t reconnect = sock->has_reconnect ? sock->reconnect : 0;
QIOChannelSocket *sioc = NULL; QIOChannelSocket *sioc = NULL;
SocketAddress *addr;
s->is_listen = is_listen; s->is_listen = is_listen;
s->is_telnet = is_telnet; s->is_telnet = is_telnet;
@ -905,11 +905,11 @@ static void qmp_chardev_open_socket(Chardev *chr,
} }
} }
s->addr = QAPI_CLONE(SocketAddress, sock->addr); s->addr = addr = socket_address_flatten(sock->addr);
qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_RECONNECTABLE); qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_RECONNECTABLE);
/* TODO SOCKET_ADDRESS_FD where fd has AF_UNIX */ /* TODO SOCKET_ADDRESS_FD where fd has AF_UNIX */
if (addr->type == SOCKET_ADDRESS_KIND_UNIX) { if (addr->type == SOCKET_ADDRESS_TYPE_UNIX) {
qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS); qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS);
} }
@ -985,7 +985,7 @@ static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend,
const char *host = qemu_opt_get(opts, "host"); const char *host = qemu_opt_get(opts, "host");
const char *port = qemu_opt_get(opts, "port"); const char *port = qemu_opt_get(opts, "port");
const char *tls_creds = qemu_opt_get(opts, "tls-creds"); const char *tls_creds = qemu_opt_get(opts, "tls-creds");
SocketAddress *addr; SocketAddressLegacy *addr;
ChardevSocket *sock; ChardevSocket *sock;
backend->type = CHARDEV_BACKEND_KIND_SOCKET; backend->type = CHARDEV_BACKEND_KIND_SOCKET;
@ -1022,14 +1022,14 @@ static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend,
sock->reconnect = reconnect; sock->reconnect = reconnect;
sock->tls_creds = g_strdup(tls_creds); sock->tls_creds = g_strdup(tls_creds);
addr = g_new0(SocketAddress, 1); addr = g_new0(SocketAddressLegacy, 1);
if (path) { if (path) {
UnixSocketAddress *q_unix; UnixSocketAddress *q_unix;
addr->type = SOCKET_ADDRESS_KIND_UNIX; addr->type = SOCKET_ADDRESS_LEGACY_KIND_UNIX;
q_unix = addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); q_unix = addr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
q_unix->path = g_strdup(path); q_unix->path = g_strdup(path);
} else { } else {
addr->type = SOCKET_ADDRESS_KIND_INET; addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
addr->u.inet.data = g_new(InetSocketAddress, 1); addr->u.inet.data = g_new(InetSocketAddress, 1);
*addr->u.inet.data = (InetSocketAddress) { *addr->u.inet.data = (InetSocketAddress) {
.host = g_strdup(host), .host = g_strdup(host),

20
chardev/char-udp.c
View File

@ -134,7 +134,7 @@ static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
const char *localaddr = qemu_opt_get(opts, "localaddr"); const char *localaddr = qemu_opt_get(opts, "localaddr");
const char *localport = qemu_opt_get(opts, "localport"); const char *localport = qemu_opt_get(opts, "localport");
bool has_local = false; bool has_local = false;
SocketAddress *addr; SocketAddressLegacy *addr;
ChardevUdp *udp; ChardevUdp *udp;
backend->type = CHARDEV_BACKEND_KIND_UDP; backend->type = CHARDEV_BACKEND_KIND_UDP;
@ -159,8 +159,8 @@ static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
udp = backend->u.udp.data = g_new0(ChardevUdp, 1); udp = backend->u.udp.data = g_new0(ChardevUdp, 1);
qemu_chr_parse_common(opts, qapi_ChardevUdp_base(udp)); qemu_chr_parse_common(opts, qapi_ChardevUdp_base(udp));
addr = g_new0(SocketAddress, 1); addr = g_new0(SocketAddressLegacy, 1);
addr->type = SOCKET_ADDRESS_KIND_INET; addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
addr->u.inet.data = g_new(InetSocketAddress, 1); addr->u.inet.data = g_new(InetSocketAddress, 1);
*addr->u.inet.data = (InetSocketAddress) { *addr->u.inet.data = (InetSocketAddress) {
.host = g_strdup(host), .host = g_strdup(host),
@ -174,8 +174,8 @@ static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
if (has_local) { if (has_local) {
udp->has_local = true; udp->has_local = true;
addr = g_new0(SocketAddress, 1); addr = g_new0(SocketAddressLegacy, 1);
addr->type = SOCKET_ADDRESS_KIND_INET; addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
addr->u.inet.data = g_new(InetSocketAddress, 1); addr->u.inet.data = g_new(InetSocketAddress, 1);
*addr->u.inet.data = (InetSocketAddress) { *addr->u.inet.data = (InetSocketAddress) {
.host = g_strdup(localaddr), .host = g_strdup(localaddr),
@ -191,13 +191,17 @@ static void qmp_chardev_open_udp(Chardev *chr,
Error **errp) Error **errp)
{ {
ChardevUdp *udp = backend->u.udp.data; ChardevUdp *udp = backend->u.udp.data;
SocketAddress *local_addr = socket_address_flatten(udp->local);
SocketAddress *remote_addr = socket_address_flatten(udp->remote);
QIOChannelSocket *sioc = qio_channel_socket_new(); QIOChannelSocket *sioc = qio_channel_socket_new();
char *name; char *name;
UdpChardev *s = UDP_CHARDEV(chr); UdpChardev *s = UDP_CHARDEV(chr);
int ret;
if (qio_channel_socket_dgram_sync(sioc, ret = qio_channel_socket_dgram_sync(sioc, local_addr, remote_addr, errp);
udp->local, udp->remote, qapi_free_SocketAddress(local_addr);
errp) < 0) { qapi_free_SocketAddress(remote_addr);
if (ret < 0) {
object_unref(OBJECT(sioc)); object_unref(OBJECT(sioc));
return; return;
} }

3
hmp.c
View File

@ -34,6 +34,7 @@
#include "qapi-visit.h" #include "qapi-visit.h"
#include "qom/object_interfaces.h" #include "qom/object_interfaces.h"
#include "ui/console.h" #include "ui/console.h"
#include "block/nbd.h"
#include "block/qapi.h" #include "block/qapi.h"
#include "qemu-io.h" #include "qemu-io.h"
#include "qemu/cutils.h" #include "qemu/cutils.h"
@ -2121,7 +2122,7 @@ void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
goto exit; goto exit;
} }
qmp_nbd_server_start(addr, false, NULL, &local_err); nbd_server_start(addr, NULL, &local_err);
qapi_free_SocketAddress(addr); qapi_free_SocketAddress(addr);
if (local_err != NULL) { if (local_err != NULL) {
goto exit; goto exit;

2
hw/block/xen_disk.c
View File

@ -1082,7 +1082,7 @@ static int blk_connect(struct XenDevice *xendev)
if (strcmp(blkdev->fileproto, "<unset>")) { if (strcmp(blkdev->fileproto, "<unset>")) {
options = qdict_new(); options = qdict_new();
qdict_put(options, "driver", qstring_from_str(blkdev->fileproto)); qdict_put_str(options, "driver", blkdev->fileproto);
} }
/* setup via xenbus -> create new block driver instance */ /* setup via xenbus -> create new block driver instance */

48
hw/pci/pcie_aer.c
View File

@ -44,6 +44,13 @@
#define PCI_ERR_SRC_COR_OFFS 0 #define PCI_ERR_SRC_COR_OFFS 0
#define PCI_ERR_SRC_UNCOR_OFFS 2 #define PCI_ERR_SRC_UNCOR_OFFS 2
typedef struct PCIEErrorDetails {
const char *id;
const char *root_bus;
int bus;
int devfn;
} PCIEErrorDetails;
/* From 6.2.7 Error Listing and Rules. Table 6-2, 6-3 and 6-4 */ /* From 6.2.7 Error Listing and Rules. Table 6-2, 6-3 and 6-4 */
static uint32_t pcie_aer_uncor_default_severity(uint32_t status) static uint32_t pcie_aer_uncor_default_severity(uint32_t status)
{ {
@ -369,7 +376,7 @@ static void pcie_aer_msg_root_port(PCIDevice *dev, const PCIEAERMsg *msg)
* *
* Walk up the bus tree from the device, propagate the error message. * Walk up the bus tree from the device, propagate the error message.
*/ */
void pcie_aer_msg(PCIDevice *dev, const PCIEAERMsg *msg) static void pcie_aer_msg(PCIDevice *dev, const PCIEAERMsg *msg)
{ {
uint8_t type; uint8_t type;
@ -624,7 +631,7 @@ static bool pcie_aer_inject_uncor_error(PCIEAERInject *inj, bool is_fatal)
* Figure 6-2: Flowchart Showing Sequence of Device Error Signaling and Logging * Figure 6-2: Flowchart Showing Sequence of Device Error Signaling and Logging
* Operations * Operations
*/ */
int pcie_aer_inject_error(PCIDevice *dev, const PCIEAERErr *err) static int pcie_aer_inject_error(PCIDevice *dev, const PCIEAERErr *err)
{ {
uint8_t *aer_cap = NULL; uint8_t *aer_cap = NULL;
uint16_t devctl = 0; uint16_t devctl = 0;
@ -942,8 +949,14 @@ static int pcie_aer_parse_error_string(const char *error_name,
return -EINVAL; return -EINVAL;
} }
/*
* Inject an error described by @qdict.
* On success, set @details to show where error was sent.
* Return negative errno if injection failed and a message was emitted.
*/
static int do_pcie_aer_inject_error(Monitor *mon, static int do_pcie_aer_inject_error(Monitor *mon,
const QDict *qdict, QObject **ret_data) const QDict *qdict,
PCIEErrorDetails *details)
{ {
const char *id = qdict_get_str(qdict, "id"); const char *id = qdict_get_str(qdict, "id");
const char *error_name; const char *error_name;
@ -1005,33 +1018,28 @@ static int do_pcie_aer_inject_error(Monitor *mon,
err.prefix[3] = qdict_get_try_int(qdict, "prefix3", 0); err.prefix[3] = qdict_get_try_int(qdict, "prefix3", 0);
ret = pcie_aer_inject_error(dev, &err); ret = pcie_aer_inject_error(dev, &err);
*ret_data = qobject_from_jsonf("{'id': %s, " if (ret < 0) {
"'root_bus': %s, 'bus': %d, 'devfn': %d, " monitor_printf(mon, "failed to inject error: %s\n",
"'ret': %d}", strerror(-ret));
id, pci_root_bus_path(dev), return ret;
pci_bus_num(dev->bus), dev->devfn, }
ret); details->id = id;
assert(*ret_data); details->root_bus = pci_root_bus_path(dev);
details->bus = pci_bus_num(dev->bus);
details->devfn = dev->devfn;
return 0; return 0;
} }
void hmp_pcie_aer_inject_error(Monitor *mon, const QDict *qdict) void hmp_pcie_aer_inject_error(Monitor *mon, const QDict *qdict)
{ {
QObject *data; PCIEErrorDetails data;
int devfn;
if (do_pcie_aer_inject_error(mon, qdict, &data) < 0) { if (do_pcie_aer_inject_error(mon, qdict, &data) < 0) {
return; return;
} }
qdict = qobject_to_qdict(data);
assert(qdict);
devfn = (int)qdict_get_int(qdict, "devfn");
monitor_printf(mon, "OK id: %s root bus: %s, bus: %x devfn: %x.%x\n", monitor_printf(mon, "OK id: %s root bus: %s, bus: %x devfn: %x.%x\n",
qdict_get_str(qdict, "id"), data.id, data.root_bus, data.bus,
qdict_get_str(qdict, "root_bus"), PCI_SLOT(data.devfn), PCI_FUNC(data.devfn));
(int) qdict_get_int(qdict, "bus"),
PCI_SLOT(devfn), PCI_FUNC(devfn));
} }

12
hw/usb/xen-usb.c
View File

@ -746,16 +746,16 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
portname++; portname++;
qdict = qdict_new(); qdict = qdict_new();
qdict_put(qdict, "driver", qstring_from_str("usb-host")); qdict_put_str(qdict, "driver", "usb-host");
tmp = g_strdup_printf("%s.0", usbif->xendev.qdev.id); tmp = g_strdup_printf("%s.0", usbif->xendev.qdev.id);
qdict_put(qdict, "bus", qstring_from_str(tmp)); qdict_put_str(qdict, "bus", tmp);
g_free(tmp); g_free(tmp);
tmp = g_strdup_printf("%s-%u", usbif->xendev.qdev.id, port); tmp = g_strdup_printf("%s-%u", usbif->xendev.qdev.id, port);
qdict_put(qdict, "id", qstring_from_str(tmp)); qdict_put_str(qdict, "id", tmp);
g_free(tmp); g_free(tmp);
qdict_put(qdict, "port", qint_from_int(port)); qdict_put_int(qdict, "port", port);
qdict_put(qdict, "hostbus", qint_from_int(atoi(busid))); qdict_put_int(qdict, "hostbus", atoi(busid));
qdict_put(qdict, "hostport", qstring_from_str(portname)); qdict_put_str(qdict, "hostport", portname);
opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err); opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err);
if (local_err) { if (local_err) {
goto err; goto err;

3
include/block/nbd.h
View File

@ -164,4 +164,7 @@ void nbd_client_new(NBDExport *exp,
void nbd_client_get(NBDClient *client); void nbd_client_get(NBDClient *client);
void nbd_client_put(NBDClient *client); void nbd_client_put(NBDClient *client);
void nbd_server_start(SocketAddress *addr, const char *tls_creds,
Error **errp);
#endif #endif

4
include/hw/pci/pcie_aer.h
View File

@ -100,8 +100,4 @@ void pcie_aer_root_write_config(PCIDevice *dev,
uint32_t addr, uint32_t val, int len, uint32_t addr, uint32_t val, int len,
uint32_t root_cmd_prev); uint32_t root_cmd_prev);
/* error injection */
int pcie_aer_inject_error(PCIDevice *dev, const PCIEAERErr *err);
void pcie_aer_msg(PCIDevice *dev, const PCIEAERMsg *msg);
#endif /* QEMU_PCIE_AER_H */ #endif /* QEMU_PCIE_AER_H */

4
include/io/channel-socket.h
View File

@ -205,7 +205,7 @@ void qio_channel_socket_dgram_async(QIOChannelSocket *ioc,
* Get the string representation of the local socket * Get the string representation of the local socket
* address. A pointer to the allocated address information * address. A pointer to the allocated address information
* struct will be returned, which the caller is required to * struct will be returned, which the caller is required to
* release with a call qapi_free_SocketAddress when no * release with a call qapi_free_SocketAddress() when no
* longer required. * longer required.
* *
* Returns: 0 on success, -1 on error * Returns: 0 on success, -1 on error
@ -222,7 +222,7 @@ qio_channel_socket_get_local_address(QIOChannelSocket *ioc,
* Get the string representation of the local socket * Get the string representation of the local socket
* address. A pointer to the allocated address information * address. A pointer to the allocated address information
* struct will be returned, which the caller is required to * struct will be returned, which the caller is required to
* release with a call qapi_free_SocketAddress when no * release with a call qapi_free_SocketAddress() when no
* longer required. * longer required.
* *
* Returns: the socket address struct, or NULL on error * Returns: the socket address struct, or NULL on error

14
include/qapi/clone-visitor.h
View File

@ -24,6 +24,9 @@ typedef struct QapiCloneVisitor QapiCloneVisitor;
void *qapi_clone(const void *src, void (*visit_type)(Visitor *, const char *, void *qapi_clone(const void *src, void (*visit_type)(Visitor *, const char *,
void **, Error **)); void **, Error **));
void qapi_clone_members(void *dst, const void *src, size_t sz,
void (*visit_type_members)(Visitor *, void *,
Error **));
/* /*
* Deep-clone QAPI object @src of the given @type, and return the result. * Deep-clone QAPI object @src of the given @type, and return the result.
@ -36,4 +39,15 @@ void *qapi_clone(const void *src, void (*visit_type)(Visitor *, const char *,
(void (*)(Visitor *, const char *, void**, \ (void (*)(Visitor *, const char *, void**, \
Error **))visit_type_ ## type)) Error **))visit_type_ ## type))
/*
* Copy deep clones of @type members from @src to @dst.
*
* Not usable on QAPI scalars (integers, strings, enums), nor on a
* QAPI object that references the 'any' type.
*/
#define QAPI_CLONE_MEMBERS(type, dst, src) \
qapi_clone_members(dst, src, sizeof(type), \
(void (*)(Visitor *, void *, \
Error **))visit_type_ ## type ## _members)
#endif #endif

8
include/qapi/qmp/qdict.h
View File

@ -52,6 +52,14 @@ void qdict_destroy_obj(QObject *obj);
#define qdict_put(qdict, key, obj) \ #define qdict_put(qdict, key, obj) \
qdict_put_obj(qdict, key, QOBJECT(obj)) qdict_put_obj(qdict, key, QOBJECT(obj))
/* Helpers for int, bool, and string */
#define qdict_put_int(qdict, key, value) \
qdict_put(qdict, key, qint_from_int(value))
#define qdict_put_bool(qdict, key, value) \
qdict_put(qdict, key, qbool_from_bool(value))
#define qdict_put_str(qdict, key, value) \
qdict_put(qdict, key, qstring_from_str(value))
/* High level helpers */ /* High level helpers */
double qdict_get_double(const QDict *qdict, const char *key); double qdict_get_double(const QDict *qdict, const char *key);
int64_t qdict_get_int(const QDict *qdict, const char *key); int64_t qdict_get_int(const QDict *qdict, const char *key);

8
include/qapi/qmp/qlist.h
View File

@ -29,6 +29,14 @@ typedef struct QList {
#define qlist_append(qlist, obj) \ #define qlist_append(qlist, obj) \
qlist_append_obj(qlist, QOBJECT(obj)) qlist_append_obj(qlist, QOBJECT(obj))
/* Helpers for int, bool, and string */
#define qlist_append_int(qlist, value) \
qlist_append(qlist, qint_from_int(value))
#define qlist_append_bool(qlist, value) \
qlist_append(qlist, qbool_from_bool(value))
#define qlist_append_str(qlist, value) \
qlist_append(qlist, qstring_from_str(value))
#define QLIST_FOREACH_ENTRY(qlist, var) \ #define QLIST_FOREACH_ENTRY(qlist, var) \
for ((var) = ((qlist)->head.tqh_first); \ for ((var) = ((qlist)->head.tqh_first); \
(var); \ (var); \

6
include/qapi/visitor.h
View File

@ -63,8 +63,10 @@
* The @name parameter of visit_type_FOO() describes the relation * The @name parameter of visit_type_FOO() describes the relation
* between this QAPI value and its parent container. When visiting * between this QAPI value and its parent container. When visiting
* the root of a tree, @name is ignored; when visiting a member of an * the root of a tree, @name is ignored; when visiting a member of an
* object, @name is the key associated with the value; and when * object, @name is the key associated with the value; when visiting a
* visiting a member of a list, @name is NULL. * member of a list, @name is NULL; and when visiting the member of an
* alternate, @name should equal the name used for visiting the
* alternate.
* *
* The visit_type_FOO() functions expect a non-null @obj argument; * The visit_type_FOO() functions expect a non-null @obj argument;
* they allocate *@obj during input visits, leave it unchanged on * they allocate *@obj during input visits, leave it unchanged on

16
include/qemu/sockets.h
View File

@ -34,7 +34,7 @@ typedef void NonBlockingConnectHandler(int fd, Error *err, void *opaque);
int inet_ai_family_from_address(InetSocketAddress *addr, int inet_ai_family_from_address(InetSocketAddress *addr,
Error **errp); Error **errp);
InetSocketAddress *inet_parse(const char *str, Error **errp); int inet_parse(InetSocketAddress *addr, const char *str, Error **errp);
int inet_connect(const char *str, Error **errp); int inet_connect(const char *str, Error **errp);
int inet_connect_saddr(InetSocketAddress *saddr, int inet_connect_saddr(InetSocketAddress *saddr,
NonBlockingConnectHandler *callback, void *opaque, NonBlockingConnectHandler *callback, void *opaque,
@ -65,7 +65,7 @@ int socket_init(void);
* Get the string representation of the socket * Get the string representation of the socket
* address. A pointer to the allocated address information * address. A pointer to the allocated address information
* struct will be returned, which the caller is required to * struct will be returned, which the caller is required to
* release with a call qapi_free_SocketAddress when no * release with a call qapi_free_SocketAddress() when no
* longer required. * longer required.
* *
* Returns: the socket address struct, or NULL on error * Returns: the socket address struct, or NULL on error
@ -83,7 +83,7 @@ socket_sockaddr_to_address(struct sockaddr_storage *sa,
* Get the string representation of the local socket * Get the string representation of the local socket
* address. A pointer to the allocated address information * address. A pointer to the allocated address information
* struct will be returned, which the caller is required to * struct will be returned, which the caller is required to
* release with a call qapi_free_SocketAddress when no * release with a call qapi_free_SocketAddress() when no
* longer required. * longer required.
* *
* Returns: the socket address struct, or NULL on error * Returns: the socket address struct, or NULL on error
@ -98,7 +98,7 @@ SocketAddress *socket_local_address(int fd, Error **errp);
* Get the string representation of the remote socket * Get the string representation of the remote socket
* address. A pointer to the allocated address information * address. A pointer to the allocated address information
* struct will be returned, which the caller is required to * struct will be returned, which the caller is required to
* release with a call qapi_free_SocketAddress when no * release with a call qapi_free_SocketAddress() when no
* longer required. * longer required.
* *
* Returns: the socket address struct, or NULL on error * Returns: the socket address struct, or NULL on error
@ -121,14 +121,14 @@ SocketAddress *socket_remote_address(int fd, Error **errp);
char *socket_address_to_string(struct SocketAddress *addr, Error **errp); char *socket_address_to_string(struct SocketAddress *addr, Error **errp);
/** /**
* socket_address_crumple: * socket_address_flatten:
* @addr_flat: the socket address to crumple * @addr: the socket address to flatten
* *
* Convert SocketAddressFlat to SocketAddress. Caller is responsible * Convert SocketAddressLegacy to SocketAddress. Caller is responsible
* for freeing with qapi_free_SocketAddress(). * for freeing with qapi_free_SocketAddress().
* *
* Returns: the argument converted to SocketAddress. * Returns: the argument converted to SocketAddress.
*/ */
SocketAddress *socket_address_crumple(SocketAddressFlat *addr_flat); SocketAddress *socket_address_flatten(SocketAddressLegacy *addr);
#endif /* QEMU_SOCKETS_H */ #endif /* QEMU_SOCKETS_H */

17
io/dns-resolver.c
View File

@ -51,7 +51,7 @@ static int qio_dns_resolver_lookup_sync_inet(QIODNSResolver *resolver,
Error **errp) Error **errp)
{ {
struct addrinfo ai, *res, *e; struct addrinfo ai, *res, *e;
InetSocketAddress *iaddr = addr->u.inet.data; InetSocketAddress *iaddr = &addr->u.inet;
char port[33]; char port[33];
char uaddr[INET6_ADDRSTRLEN + 1]; char uaddr[INET6_ADDRSTRLEN + 1];
char uport[33]; char uport[33];
@ -102,15 +102,14 @@ static int qio_dns_resolver_lookup_sync_inet(QIODNSResolver *resolver,
/* create socket + bind */ /* create socket + bind */
for (i = 0, e = res; e != NULL; i++, e = e->ai_next) { for (i = 0, e = res; e != NULL; i++, e = e->ai_next) {
SocketAddress *newaddr = g_new0(SocketAddress, 1); SocketAddress *newaddr = g_new0(SocketAddress, 1);
InetSocketAddress *newiaddr = g_new0(InetSocketAddress, 1);
newaddr->u.inet.data = newiaddr; newaddr->type = SOCKET_ADDRESS_TYPE_INET;
newaddr->type = SOCKET_ADDRESS_KIND_INET;
getnameinfo((struct sockaddr *)e->ai_addr, e->ai_addrlen, getnameinfo((struct sockaddr *)e->ai_addr, e->ai_addrlen,
uaddr, INET6_ADDRSTRLEN, uport, 32, uaddr, INET6_ADDRSTRLEN, uport, 32,
NI_NUMERICHOST | NI_NUMERICSERV); NI_NUMERICHOST | NI_NUMERICSERV);
*newiaddr = (InetSocketAddress){ newaddr->u.inet = (InetSocketAddress){
.host = g_strdup(uaddr), .host = g_strdup(uaddr),
.port = g_strdup(uport), .port = g_strdup(uport),
.has_numeric = true, .has_numeric = true,
@ -149,16 +148,16 @@ int qio_dns_resolver_lookup_sync(QIODNSResolver *resolver,
Error **errp) Error **errp)
{ {
switch (addr->type) { switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_TYPE_INET:
return qio_dns_resolver_lookup_sync_inet(resolver, return qio_dns_resolver_lookup_sync_inet(resolver,
addr, addr,
naddrs, naddrs,
addrs, addrs,
errp); errp);
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
case SOCKET_ADDRESS_KIND_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
case SOCKET_ADDRESS_KIND_FD: case SOCKET_ADDRESS_TYPE_FD:
return qio_dns_resolver_lookup_sync_nop(resolver, return qio_dns_resolver_lookup_sync_nop(resolver,
addr, addr,
naddrs, naddrs,

4
migration/rdma.c
View File

@ -2506,8 +2506,8 @@ static void *qemu_rdma_data_init(const char *host_port, Error **errp)
rdma->current_index = -1; rdma->current_index = -1;
rdma->current_chunk = -1; rdma->current_chunk = -1;
addr = inet_parse(host_port, NULL); addr = g_new(InetSocketAddress, 1);
if (addr != NULL) { if (!inet_parse(addr, host_port, NULL)) {
rdma->port = atoi(addr->port); rdma->port = atoi(addr->port);
rdma->host = g_strdup(addr->host); rdma->host = g_strdup(addr->host);
} else { } else {

20
migration/socket.c
View File

@ -27,17 +27,16 @@
static SocketAddress *tcp_build_address(const char *host_port, Error **errp) static SocketAddress *tcp_build_address(const char *host_port, Error **errp)
{ {
InetSocketAddress *iaddr = inet_parse(host_port, errp);
SocketAddress *saddr; SocketAddress *saddr;
if (!iaddr) { saddr = g_new0(SocketAddress, 1);
saddr->type = SOCKET_ADDRESS_TYPE_INET;
if (inet_parse(&saddr->u.inet, host_port, errp)) {
qapi_free_SocketAddress(saddr);
return NULL; return NULL;
} }
saddr = g_new0(SocketAddress, 1);
saddr->type = SOCKET_ADDRESS_KIND_INET;
saddr->u.inet.data = iaddr;
return saddr; return saddr;
} }
@ -47,9 +46,8 @@ static SocketAddress *unix_build_address(const char *path)
SocketAddress *saddr; SocketAddress *saddr;
saddr = g_new0(SocketAddress, 1); saddr = g_new0(SocketAddress, 1);
saddr->type = SOCKET_ADDRESS_KIND_UNIX; saddr->type = SOCKET_ADDRESS_TYPE_UNIX;
saddr->u.q_unix.data = g_new0(UnixSocketAddress, 1); saddr->u.q_unix.path = g_strdup(path);
saddr->u.q_unix.data->path = g_strdup(path);
return saddr; return saddr;
} }
@ -96,8 +94,8 @@ static void socket_start_outgoing_migration(MigrationState *s,
struct SocketConnectData *data = g_new0(struct SocketConnectData, 1); struct SocketConnectData *data = g_new0(struct SocketConnectData, 1);
data->s = s; data->s = s;
if (saddr->type == SOCKET_ADDRESS_KIND_INET) { if (saddr->type == SOCKET_ADDRESS_TYPE_INET) {
data->hostname = g_strdup(saddr->u.inet.data->host); data->hostname = g_strdup(saddr->u.inet.host);
} }
qio_channel_set_name(QIO_CHANNEL(sioc), "migration-socket-outgoing"); qio_channel_set_name(QIO_CHANNEL(sioc), "migration-socket-outgoing");

23
monitor.c
View File

@ -2769,7 +2769,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
} }
goto fail; goto fail;
} }
qdict_put(qdict, key, qstring_from_str(buf)); qdict_put_str(qdict, key, buf);
} }
break; break;
case 'O': case 'O':
@ -2871,9 +2871,9 @@ static QDict *monitor_parse_arguments(Monitor *mon,
size = -1; size = -1;
} }
} }
qdict_put(qdict, "count", qint_from_int(count)); qdict_put_int(qdict, "count", count);
qdict_put(qdict, "format", qint_from_int(format)); qdict_put_int(qdict, "format", format);
qdict_put(qdict, "size", qint_from_int(size)); qdict_put_int(qdict, "size", size);
} }
break; break;
case 'i': case 'i':
@ -2916,7 +2916,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
} }
val <<= 20; val <<= 20;
} }
qdict_put(qdict, key, qint_from_int(val)); qdict_put_int(qdict, key, val);
} }
break; break;
case 'o': case 'o':
@ -2939,7 +2939,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
monitor_printf(mon, "invalid size\n"); monitor_printf(mon, "invalid size\n");
goto fail; goto fail;
} }
qdict_put(qdict, key, qint_from_int(val)); qdict_put_int(qdict, key, val);
p = end; p = end;
} }
break; break;
@ -2995,7 +2995,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
monitor_printf(mon, "Expected 'on' or 'off'\n"); monitor_printf(mon, "Expected 'on' or 'off'\n");
goto fail; goto fail;
} }
qdict_put(qdict, key, qbool_from_bool(val)); qdict_put_bool(qdict, key, val);
} }
break; break;
case '-': case '-':
@ -3026,7 +3026,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
} else { } else {
/* has option */ /* has option */
p++; p++;
qdict_put(qdict, key, qbool_from_bool(true)); qdict_put_bool(qdict, key, true);
} }
} }
} }
@ -3052,7 +3052,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
cmd->name); cmd->name);
goto fail; goto fail;
} }
qdict_put(qdict, key, qstring_from_str(p)); qdict_put_str(qdict, key, p);
p += len; p += len;
} }
break; break;
@ -3831,9 +3831,8 @@ static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
QapiErrorClass_lookup[ERROR_CLASS_COMMAND_NOT_FOUND])) { QapiErrorClass_lookup[ERROR_CLASS_COMMAND_NOT_FOUND])) {
/* Provide a more useful error message */ /* Provide a more useful error message */
qdict_del(qdict, "desc"); qdict_del(qdict, "desc");
qdict_put(qdict, "desc", qdict_put_str(qdict, "desc", "Expecting capabilities negotiation"
qstring_from_str("Expecting capabilities negotiation" " with 'qmp_capabilities'");
" with 'qmp_capabilities'"));
} }
} }

35
qapi-schema.json
View File

@ -4122,13 +4122,19 @@
'port': 'str' } } 'port': 'str' } }
## ##
# @SocketAddress: # @SocketAddressLegacy:
# #
# Captures the address of a socket, which could also be a named file descriptor # Captures the address of a socket, which could also be a named file descriptor
#
# Note: This type is deprecated in favor of SocketAddress. The
# difference between SocketAddressLegacy and SocketAddress is that the
# latter is a flat union rather than a simple union. Flat is nicer
# because it avoids nesting on the wire, i.e. that form has fewer {}.
# #
# Since: 1.3 # Since: 1.3
## ##
{ 'union': 'SocketAddress', { 'union': 'SocketAddressLegacy',
'data': { 'data': {
'inet': 'InetSocketAddress', 'inet': 'InetSocketAddress',
'unix': 'UnixSocketAddress', 'unix': 'UnixSocketAddress',
@ -4136,9 +4142,9 @@
'fd': 'String' } } 'fd': 'String' } }
## ##
# @SocketAddressFlatType: # @SocketAddressType:
# #
# Available SocketAddressFlat types # Available SocketAddress types
# #
# @inet: Internet address # @inet: Internet address
# #
@ -4146,24 +4152,21 @@
# #
# Since: 2.9 # Since: 2.9
## ##
{ 'enum': 'SocketAddressFlatType', { 'enum': 'SocketAddressType',
'data': [ 'inet', 'unix', 'vsock', 'fd' ] } 'data': [ 'inet', 'unix', 'vsock', 'fd' ] }
## ##
# @SocketAddressFlat: # @SocketAddress:
# #
# Captures the address of a socket # Captures the address of a socket, which could also be a named file
# descriptor
# #
# @type: Transport type # @type: Transport type
# #
# This is just like SocketAddress, except it's a flat union rather
# than a simple union. Nicer because it avoids nesting on the wire,
# i.e. this form has fewer {}.
#
# Since: 2.9 # Since: 2.9
## ##
{ 'union': 'SocketAddressFlat', { 'union': 'SocketAddress',
'base': { 'type': 'SocketAddressFlatType' }, 'base': { 'type': 'SocketAddressType' },
'discriminator': 'type', 'discriminator': 'type',
'data': { 'inet': 'InetSocketAddress', 'data': { 'inet': 'InetSocketAddress',
'unix': 'UnixSocketAddress', 'unix': 'UnixSocketAddress',
@ -4886,7 +4889,7 @@
# #
# Since: 1.4 # Since: 1.4
## ##
{ 'struct': 'ChardevSocket', 'data': { 'addr' : 'SocketAddress', { 'struct': 'ChardevSocket', 'data': { 'addr' : 'SocketAddressLegacy',
'*tls-creds' : 'str', '*tls-creds' : 'str',
'*server' : 'bool', '*server' : 'bool',
'*wait' : 'bool', '*wait' : 'bool',
@ -4906,8 +4909,8 @@
# #
# Since: 1.5 # Since: 1.5
## ##
{ 'struct': 'ChardevUdp', 'data': { 'remote' : 'SocketAddress', { 'struct': 'ChardevUdp', 'data': { 'remote' : 'SocketAddressLegacy',
'*local' : 'SocketAddress' }, '*local' : 'SocketAddressLegacy' },
'base': 'ChardevCommon' } 'base': 'ChardevCommon' }
## ##

6
qapi/block-core.json
View File

@ -2522,7 +2522,7 @@
{ 'struct': 'BlockdevOptionsGluster', { 'struct': 'BlockdevOptionsGluster',
'data': { 'volume': 'str', 'data': { 'volume': 'str',
'path': 'str', 'path': 'str',
'server': ['SocketAddressFlat'], 'server': ['SocketAddress'],
'*debug': 'int', '*debug': 'int',
'*logfile': 'str' } } '*logfile': 'str' } }
@ -2634,7 +2634,7 @@
# Since: 2.9 # Since: 2.9
## ##
{ 'struct': 'BlockdevOptionsSheepdog', { 'struct': 'BlockdevOptionsSheepdog',
'data': { 'server': 'SocketAddressFlat', 'data': { 'server': 'SocketAddress',
'vdi': 'str', 'vdi': 'str',
'*snap-id': 'uint32', '*snap-id': 'uint32',
'*tag': 'str' } } '*tag': 'str' } }
@ -2849,7 +2849,7 @@
# Since: 2.9 # Since: 2.9
## ##
{ 'struct': 'BlockdevOptionsNbd', { 'struct': 'BlockdevOptionsNbd',
'data': { 'server': 'SocketAddressFlat', 'data': { 'server': 'SocketAddress',
'*export': 'str', '*export': 'str',
'*tls-creds': 'str' } } '*tls-creds': 'str' } }

2
qapi/block.json
View File

@ -204,7 +204,7 @@
# Since: 1.3.0 # Since: 1.3.0
## ##
{ 'command': 'nbd-server-start', { 'command': 'nbd-server-start',
'data': { 'addr': 'SocketAddress', 'data': { 'addr': 'SocketAddressLegacy',
'*tls-creds': 'str'} } '*tls-creds': 'str'} }
## ##

13
qapi/qapi-clone-visitor.c
View File

@ -180,3 +180,16 @@ void *qapi_clone(const void *src, void (*visit_type)(Visitor *, const char *,
visit_free(v); visit_free(v);
return dst; return dst;
} }
void qapi_clone_members(void *dst, const void *src, size_t sz,
void (*visit_type_members)(Visitor *, void *,
Error **))
{
Visitor *v;
v = qapi_clone_visitor_new();
memcpy(dst, src, sz);
to_qcv(v)->depth++;
visit_type_members(v, dst, &error_abort);
visit_free(v);
}

14
qapi/qmp-dispatch.c
View File

@ -30,7 +30,7 @@ static QDict *qmp_dispatch_check_obj(const QObject *request, Error **errp)
dict = qobject_to_qdict(request); dict = qobject_to_qdict(request);
if (!dict) { if (!dict) {
error_setg(errp, "Expected '%s' in QMP input", "object"); error_setg(errp, "QMP input must be a JSON object");
return NULL; return NULL;
} }
@ -41,26 +41,26 @@ static QDict *qmp_dispatch_check_obj(const QObject *request, Error **errp)
if (!strcmp(arg_name, "execute")) { if (!strcmp(arg_name, "execute")) {
if (qobject_type(arg_obj) != QTYPE_QSTRING) { if (qobject_type(arg_obj) != QTYPE_QSTRING) {
error_setg(errp, "QMP input object member '%s' expects '%s'", error_setg(errp,
"execute", "string"); "QMP input member 'execute' must be a string");
return NULL; return NULL;
} }
has_exec_key = true; has_exec_key = true;
} else if (!strcmp(arg_name, "arguments")) { } else if (!strcmp(arg_name, "arguments")) {
if (qobject_type(arg_obj) != QTYPE_QDICT) { if (qobject_type(arg_obj) != QTYPE_QDICT) {
error_setg(errp, "QMP input object member '%s' expects '%s'", error_setg(errp,
"arguments", "object"); "QMP input member 'arguments' must be an object");
return NULL; return NULL;
} }
} else { } else {
error_setg(errp, "QMP input object member '%s' is unexpected", error_setg(errp, "QMP input member '%s' is unexpected",
arg_name); arg_name);
return NULL; return NULL;
} }
} }
if (!has_exec_key) { if (!has_exec_key) {
error_setg(errp, "Expected '%s' in QMP input", "execute"); error_setg(errp, "QMP input lacks member 'execute'");
return NULL; return NULL;
} }

2
qapi/qmp-event.c
View File

@ -51,7 +51,7 @@ static void timestamp_put(QDict *qdict)
QDict *qmp_event_build_dict(const char *event_name) QDict *qmp_event_build_dict(const char *event_name)
{ {
QDict *dict = qdict_new(); QDict *dict = qdict_new();
qdict_put(dict, "event", qstring_from_str(event_name)); qdict_put_str(dict, "event", event_name);
timestamp_put(dict); timestamp_put(dict);
return dict; return dict;
} }

32
qapi/qobject-input-visitor.c
View File

@ -55,6 +55,17 @@ static QObjectInputVisitor *to_qiv(Visitor *v)
return container_of(v, QObjectInputVisitor, visitor); return container_of(v, QObjectInputVisitor, visitor);
} }
/*
* Find the full name of something @qiv is currently visiting.
* @qiv is visiting something named @name in the stack of containers
* @qiv->stack.
* If @n is zero, return its full name.
* If @n is positive, return the full name of the @n-th container
* counting from the top. The stack of containers must have at least
* @n elements.
* The returned string is valid until the next full_name_nth(@v) or
* destruction of @v.
*/
static const char *full_name_nth(QObjectInputVisitor *qiv, const char *name, static const char *full_name_nth(QObjectInputVisitor *qiv, const char *name,
int n) int n)
{ {
@ -280,6 +291,15 @@ static void qobject_input_start_struct(Visitor *v, const char *name, void **obj,
} }
} }
static void qobject_input_end_struct(Visitor *v, void **obj)
{
QObjectInputVisitor *qiv = to_qiv(v);
StackObject *tos = QSLIST_FIRST(&qiv->stack);
assert(qobject_type(tos->obj) == QTYPE_QDICT && tos->h);
qobject_input_pop(v, obj);
}
static void qobject_input_start_list(Visitor *v, const char *name, static void qobject_input_start_list(Visitor *v, const char *name,
GenericList **list, size_t size, GenericList **list, size_t size,
@ -335,6 +355,14 @@ static void qobject_input_check_list(Visitor *v, Error **errp)
} }
} }
static void qobject_input_end_list(Visitor *v, void **obj)
{
QObjectInputVisitor *qiv = to_qiv(v);
StackObject *tos = QSLIST_FIRST(&qiv->stack);
assert(qobject_type(tos->obj) == QTYPE_QLIST && !tos->h);
qobject_input_pop(v, obj);
}
static void qobject_input_start_alternate(Visitor *v, const char *name, static void qobject_input_start_alternate(Visitor *v, const char *name,
GenericAlternate **obj, size_t size, GenericAlternate **obj, size_t size,
@ -634,11 +662,11 @@ static QObjectInputVisitor *qobject_input_visitor_base_new(QObject *obj)
v->visitor.type = VISITOR_INPUT; v->visitor.type = VISITOR_INPUT;
v->visitor.start_struct = qobject_input_start_struct; v->visitor.start_struct = qobject_input_start_struct;
v->visitor.check_struct = qobject_input_check_struct; v->visitor.check_struct = qobject_input_check_struct;
v->visitor.end_struct = qobject_input_pop; v->visitor.end_struct = qobject_input_end_struct;
v->visitor.start_list = qobject_input_start_list; v->visitor.start_list = qobject_input_start_list;
v->visitor.next_list = qobject_input_next_list; v->visitor.next_list = qobject_input_next_list;
v->visitor.check_list = qobject_input_check_list; v->visitor.check_list = qobject_input_check_list;
v->visitor.end_list = qobject_input_pop; v->visitor.end_list = qobject_input_end_list;
v->visitor.start_alternate = qobject_input_start_alternate; v->visitor.start_alternate = qobject_input_start_alternate;
v->visitor.optional = qobject_input_optional; v->visitor.optional = qobject_input_optional;
v->visitor.free = qobject_input_free; v->visitor.free = qobject_input_free;

6
qemu-img.c
View File

@ -313,7 +313,7 @@ static BlockBackend *img_open_file(const char *filename,
if (fmt) { if (fmt) {
options = qdict_new(); options = qdict_new();
qdict_put(options, "driver", qstring_from_str(fmt)); qdict_put_str(options, "driver", fmt);
} }
blk = blk_new_open(filename, NULL, options, flags, &local_err); blk = blk_new_open(filename, NULL, options, flags, &local_err);
@ -3094,7 +3094,7 @@ static int img_rebase(int argc, char **argv)
if (bs->backing_format[0] != '\0') { if (bs->backing_format[0] != '\0') {
options = qdict_new(); options = qdict_new();
qdict_put(options, "driver", qstring_from_str(bs->backing_format)); qdict_put_str(options, "driver", bs->backing_format);
} }
bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name)); bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
@ -3111,7 +3111,7 @@ static int img_rebase(int argc, char **argv)
if (out_baseimg[0]) { if (out_baseimg[0]) {
if (out_basefmt) { if (out_basefmt) {
options = qdict_new(); options = qdict_new();
qdict_put(options, "driver", qstring_from_str(out_basefmt)); qdict_put_str(options, "driver", out_basefmt);
} else { } else {
options = NULL; options = NULL;
} }

2
qemu-io.c
View File

@ -601,7 +601,7 @@ int main(int argc, char **argv)
} else { } else {
if (format) { if (format) {
opts = qdict_new(); opts = qdict_new();
qdict_put(opts, "driver", qstring_from_str(format)); qdict_put_str(opts, "driver", format);
} }
if (openfile(argv[optind], flags, writethrough, opts)) { if (openfile(argv[optind], flags, writethrough, opts)) {
exit(1); exit(1);

11
qemu-nbd.c
View File

@ -395,13 +395,12 @@ static SocketAddress *nbd_build_socket_address(const char *sockpath,
saddr = g_new0(SocketAddress, 1); saddr = g_new0(SocketAddress, 1);
if (sockpath) { if (sockpath) {
saddr->type = SOCKET_ADDRESS_KIND_UNIX; saddr->type = SOCKET_ADDRESS_TYPE_UNIX;
saddr->u.q_unix.data = g_new0(UnixSocketAddress, 1); saddr->u.q_unix.path = g_strdup(sockpath);
saddr->u.q_unix.data->path = g_strdup(sockpath);
} else { } else {
InetSocketAddress *inet; InetSocketAddress *inet;
saddr->type = SOCKET_ADDRESS_KIND_INET; saddr->type = SOCKET_ADDRESS_TYPE_INET;
inet = saddr->u.inet.data = g_new0(InetSocketAddress, 1); inet = &saddr->u.inet;
inet->host = g_strdup(bindto); inet->host = g_strdup(bindto);
if (port) { if (port) {
inet->port = g_strdup(port); inet->port = g_strdup(port);
@ -959,7 +958,7 @@ int main(int argc, char **argv)
} else { } else {
if (fmt) { if (fmt) {
options = qdict_new(); options = qdict_new();
qdict_put(options, "driver", qstring_from_str(fmt)); qdict_put_str(options, "driver", fmt);
} }
blk = blk_new_open(srcpath, NULL, options, flags, &local_err); blk = blk_new_open(srcpath, NULL, options, flags, &local_err);
} }

4
qga/main.c
View File

@ -1388,9 +1388,9 @@ int main(int argc, char **argv)
addr = socket_local_address(FIRST_SOCKET_ACTIVATION_FD, NULL); addr = socket_local_address(FIRST_SOCKET_ACTIVATION_FD, NULL);
if (addr) { if (addr) {
if (addr->type == SOCKET_ADDRESS_KIND_UNIX) { if (addr->type == SOCKET_ADDRESS_TYPE_UNIX) {
config->method = g_strdup("unix-listen"); config->method = g_strdup("unix-listen");
} else if (addr->type == SOCKET_ADDRESS_KIND_VSOCK) { } else if (addr->type == SOCKET_ADDRESS_TYPE_VSOCK) {
config->method = g_strdup("vsock-listen"); config->method = g_strdup("vsock-listen");
} }

2
qobject/qdict.c
View File

@ -463,7 +463,7 @@ void qdict_set_default_str(QDict *dst, const char *key, const char *val)
return; return;
} }
qdict_put(dst, key, qstring_from_str(val)); qdict_put_str(dst, key, val);
} }
static void qdict_flatten_qdict(QDict *qdict, QDict *target, static void qdict_flatten_qdict(QDict *qdict, QDict *target,

35
scripts/coccinelle/qobject.cocci Normal file
View File

@ -0,0 +1,35 @@
// Use QDict macros where they make sense
@@
expression Obj, Key, E;
@@
(
- qdict_put_obj(Obj, Key, QOBJECT(E));
+ qdict_put(Obj, Key, E);
|
- qdict_put(Obj, Key, qint_from_int(E));
+ qdict_put_int(Obj, Key, E);
|
- qdict_put(Obj, Key, qbool_from_bool(E));
+ qdict_put_bool(Obj, Key, E);
|
- qdict_put(Obj, Key, qstring_from_str(E));
+ qdict_put_str(Obj, Key, E);
)
// Use QList macros where they make sense
@@
expression Obj, E;
@@
(
- qlist_append_obj(Obj, QOBJECT(E));
+ qlist_append(Obj, E);
|
- qlist_append(Obj, qint_from_int(E));
+ qlist_append_int(Obj, E);
|
- qlist_append(Obj, qbool_from_bool(E));
+ qlist_append_bool(Obj, E);
|
- qlist_append(Obj, qstring_from_str(E));
+ qlist_append_str(Obj, E);
)

44
scripts/qmp/qmp-shell
View File

@ -70,6 +70,9 @@ import json
import ast import ast
import readline import readline
import sys import sys
import os
import errno
import atexit
class QMPCompleter(list): class QMPCompleter(list):
def complete(self, text, state): def complete(self, text, state):
@ -109,6 +112,8 @@ class QMPShell(qmp.QEMUMonitorProtocol):
self._pretty = pretty self._pretty = pretty
self._transmode = False self._transmode = False
self._actions = list() self._actions = list()
self._histfile = os.path.join(os.path.expanduser('~'),
'.qmp-shell_history')
def __get_address(self, arg): def __get_address(self, arg):
""" """
@ -126,17 +131,36 @@ class QMPShell(qmp.QEMUMonitorProtocol):
return arg return arg
def _fill_completion(self): def _fill_completion(self):
for cmd in self.cmd('query-commands')['return']: cmds = self.cmd('query-commands')
if cmds.has_key('error'):
return
for cmd in cmds['return']:
self._completer.append(cmd['name']) self._completer.append(cmd['name'])
def __completer_setup(self): def __completer_setup(self):
self._completer = QMPCompleter() self._completer = QMPCompleter()
self._fill_completion() self._fill_completion()
readline.set_history_length(1024)
readline.set_completer(self._completer.complete) readline.set_completer(self._completer.complete)
readline.parse_and_bind("tab: complete") readline.parse_and_bind("tab: complete")
# XXX: default delimiters conflict with some command names (eg. query-), # XXX: default delimiters conflict with some command names (eg. query-),
# clearing everything as it doesn't seem to matter # clearing everything as it doesn't seem to matter
readline.set_completer_delims('') readline.set_completer_delims('')
try:
readline.read_history_file(self._histfile)
except Exception as e:
if isinstance(e, IOError) and e.errno == errno.ENOENT:
# File not found. No problem.
pass
else:
print "Failed to read history '%s'; %s" % (self._histfile, e)
atexit.register(self.__save_history)
def __save_history(self):
try:
readline.write_history_file(self._histfile)
except Exception as e:
print "Failed to save history file '%s'; %s" % (self._histfile, e)
def __parse_value(self, val): def __parse_value(self, val):
try: try:
@ -256,12 +280,15 @@ class QMPShell(qmp.QEMUMonitorProtocol):
self._print(resp) self._print(resp)
return True return True
def connect(self): def connect(self, negotiate):
self._greeting = qmp.QEMUMonitorProtocol.connect(self) self._greeting = qmp.QEMUMonitorProtocol.connect(self, negotiate)
self.__completer_setup() self.__completer_setup()
def show_banner(self, msg='Welcome to the QMP low-level shell!'): def show_banner(self, msg='Welcome to the QMP low-level shell!'):
print msg print msg
if not self._greeting:
print 'Connected'
return
version = self._greeting['QMP']['version']['qemu'] version = self._greeting['QMP']['version']['qemu']
print 'Connected to QEMU %d.%d.%d\n' % (version['major'],version['minor'],version['micro']) print 'Connected to QEMU %d.%d.%d\n' % (version['major'],version['minor'],version['micro'])
@ -369,7 +396,11 @@ def die(msg):
def fail_cmdline(option=None): def fail_cmdline(option=None):
if option: if option:
sys.stderr.write('ERROR: bad command-line option \'%s\'\n' % option) sys.stderr.write('ERROR: bad command-line option \'%s\'\n' % option)
sys.stderr.write('qemu-shell [ -v ] [ -p ] [ -H ] < UNIX socket path> | < TCP address:port >\n') sys.stderr.write('qmp-shell [ -v ] [ -p ] [ -H ] [ -N ] < UNIX socket path> | < TCP address:port >\n')
sys.stderr.write(' -v Verbose (echo command sent and received)\n')
sys.stderr.write(' -p Pretty-print JSON\n')
sys.stderr.write(' -H Use HMP interface\n')
sys.stderr.write(' -N Skip negotiate (for qemu-ga)\n')
sys.exit(1) sys.exit(1)
def main(): def main():
@ -378,6 +409,7 @@ def main():
hmp = False hmp = False
pretty = False pretty = False
verbose = False verbose = False
negotiate = True
try: try:
for arg in sys.argv[1:]: for arg in sys.argv[1:]:
@ -387,6 +419,8 @@ def main():
hmp = True hmp = True
elif arg == "-p": elif arg == "-p":
pretty = True pretty = True
elif arg == "-N":
negotiate = False
elif arg == "-v": elif arg == "-v":
verbose = True verbose = True
else: else:
@ -404,7 +438,7 @@ def main():
die('bad port number in command-line') die('bad port number in command-line')
try: try:
qemu.connect() qemu.connect(negotiate)
except qmp.QMPConnectError: except qmp.QMPConnectError:
die('Didn\'t get QMP greeting message') die('Didn\'t get QMP greeting message')
except qmp.QMPCapabilitiesError: except qmp.QMPCapabilitiesError:

4
target/s390x/cpu_models.c
View File

@ -376,12 +376,12 @@ static void cpu_model_from_info(S390CPUModel *model, const CpuModelInfo *info,
static void qdict_add_disabled_feat(const char *name, void *opaque) static void qdict_add_disabled_feat(const char *name, void *opaque)
{ {
qdict_put(opaque, name, qbool_from_bool(false)); qdict_put_bool(opaque, name, false);
} }
static void qdict_add_enabled_feat(const char *name, void *opaque) static void qdict_add_enabled_feat(const char *name, void *opaque)
{ {
qdict_put(opaque, name, qbool_from_bool(true)); qdict_put_bool(opaque, name, true);
} }
/* convert S390CPUDef into a static CpuModelInfo */ /* convert S390CPUDef into a static CpuModelInfo */

144
tests/check-qdict.c
View File

@ -47,7 +47,7 @@ static void qdict_put_obj_test(void)
qdict = qdict_new(); qdict = qdict_new();
// key "" will have tdb hash 12345 // key "" will have tdb hash 12345
qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num))); qdict_put_int(qdict, "", num);
g_assert(qdict_size(qdict) == 1); g_assert(qdict_size(qdict) == 1);
ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]); ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
@ -66,8 +66,8 @@ static void qdict_destroy_simple_test(void)
QDict *qdict; QDict *qdict;
qdict = qdict_new(); qdict = qdict_new();
qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0))); qdict_put_int(qdict, "num", 0);
qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo"))); qdict_put_str(qdict, "str", "foo");
QDECREF(qdict); QDECREF(qdict);
} }
@ -80,7 +80,7 @@ static void qdict_get_test(void)
const char *key = "test"; const char *key = "test";
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
qdict_put(tests_dict, key, qint_from_int(value)); qdict_put_int(tests_dict, key, value);
obj = qdict_get(tests_dict, key); obj = qdict_get(tests_dict, key);
g_assert(obj != NULL); g_assert(obj != NULL);
@ -98,7 +98,7 @@ static void qdict_get_int_test(void)
const char *key = "int"; const char *key = "int";
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
qdict_put(tests_dict, key, qint_from_int(value)); qdict_put_int(tests_dict, key, value);
ret = qdict_get_int(tests_dict, key); ret = qdict_get_int(tests_dict, key);
g_assert(ret == value); g_assert(ret == value);
@ -113,7 +113,7 @@ static void qdict_get_try_int_test(void)
const char *key = "int"; const char *key = "int";
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
qdict_put(tests_dict, key, qint_from_int(value)); qdict_put_int(tests_dict, key, value);
ret = qdict_get_try_int(tests_dict, key, 0); ret = qdict_get_try_int(tests_dict, key, 0);
g_assert(ret == value); g_assert(ret == value);
@ -128,7 +128,7 @@ static void qdict_get_str_test(void)
const char *str = "string"; const char *str = "string";
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
qdict_put(tests_dict, key, qstring_from_str(str)); qdict_put_str(tests_dict, key, str);
p = qdict_get_str(tests_dict, key); p = qdict_get_str(tests_dict, key);
g_assert(p != NULL); g_assert(p != NULL);
@ -144,7 +144,7 @@ static void qdict_get_try_str_test(void)
const char *str = "string"; const char *str = "string";
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
qdict_put(tests_dict, key, qstring_from_str(str)); qdict_put_str(tests_dict, key, str);
p = qdict_get_try_str(tests_dict, key); p = qdict_get_try_str(tests_dict, key);
g_assert(p != NULL); g_assert(p != NULL);
@ -188,7 +188,7 @@ static void qdict_haskey_test(void)
const char *key = "test"; const char *key = "test";
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
qdict_put(tests_dict, key, qint_from_int(0)); qdict_put_int(tests_dict, key, 0);
g_assert(qdict_haskey(tests_dict, key) == 1); g_assert(qdict_haskey(tests_dict, key) == 1);
QDECREF(tests_dict); QDECREF(tests_dict);
@ -199,7 +199,7 @@ static void qdict_del_test(void)
const char *key = "key test"; const char *key = "key test";
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
qdict_put(tests_dict, key, qstring_from_str("foo")); qdict_put_str(tests_dict, key, "foo");
g_assert(qdict_size(tests_dict) == 1); g_assert(qdict_size(tests_dict) == 1);
qdict_del(tests_dict, key); qdict_del(tests_dict, key);
@ -226,9 +226,9 @@ static void qdict_iterapi_test(void)
g_assert(qdict_first(tests_dict) == NULL); g_assert(qdict_first(tests_dict) == NULL);
qdict_put(tests_dict, "key1", qint_from_int(1)); qdict_put_int(tests_dict, "key1", 1);
qdict_put(tests_dict, "key2", qint_from_int(2)); qdict_put_int(tests_dict, "key2", 2);
qdict_put(tests_dict, "key3", qint_from_int(3)); qdict_put_int(tests_dict, "key3", 3);
count = 0; count = 0;
for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){ for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
@ -294,20 +294,20 @@ static void qdict_flatten_test(void)
* } * }
*/ */
qdict_put(dict1, "a", qint_from_int(0)); qdict_put_int(dict1, "a", 0);
qdict_put(dict1, "b", qint_from_int(1)); qdict_put_int(dict1, "b", 1);
qlist_append_obj(list1, QOBJECT(qint_from_int(23))); qlist_append_int(list1, 23);
qlist_append_obj(list1, QOBJECT(qint_from_int(66))); qlist_append_int(list1, 66);
qlist_append_obj(list1, QOBJECT(dict1)); qlist_append(list1, dict1);
qlist_append_obj(list2, QOBJECT(qint_from_int(42))); qlist_append_int(list2, 42);
qlist_append_obj(list2, QOBJECT(list1)); qlist_append(list2, list1);
qdict_put(dict2, "c", qint_from_int(2)); qdict_put_int(dict2, "c", 2);
qdict_put(dict2, "d", qint_from_int(3)); qdict_put_int(dict2, "d", 3);
qdict_put_obj(dict3, "e", QOBJECT(list2)); qdict_put(dict3, "e", list2);
qdict_put_obj(dict3, "f", QOBJECT(dict2)); qdict_put(dict3, "f", dict2);
qdict_put(dict3, "g", qint_from_int(4)); qdict_put_int(dict3, "g", 4);
qdict_flatten(dict3); qdict_flatten(dict3);
@ -369,12 +369,12 @@ static void qdict_array_split_test(void)
* This example is given in the comment of qdict_array_split(). * This example is given in the comment of qdict_array_split().
*/ */
qdict_put(test_dict, "1.x", qint_from_int(0)); qdict_put_int(test_dict, "1.x", 0);
qdict_put(test_dict, "4.y", qint_from_int(1)); qdict_put_int(test_dict, "4.y", 1);
qdict_put(test_dict, "0.a", qint_from_int(42)); qdict_put_int(test_dict, "0.a", 42);
qdict_put(test_dict, "o.o", qint_from_int(7)); qdict_put_int(test_dict, "o.o", 7);
qdict_put(test_dict, "0.b", qint_from_int(23)); qdict_put_int(test_dict, "0.b", 23);
qdict_put(test_dict, "2", qint_from_int(66)); qdict_put_int(test_dict, "2", 66);
qdict_array_split(test_dict, &test_list); qdict_array_split(test_dict, &test_list);
@ -441,9 +441,9 @@ static void qdict_array_split_test(void)
test_dict = qdict_new(); test_dict = qdict_new();
qdict_put(test_dict, "0", qint_from_int(42)); qdict_put_int(test_dict, "0", 42);
qdict_put(test_dict, "1", qint_from_int(23)); qdict_put_int(test_dict, "1", 23);
qdict_put(test_dict, "1.x", qint_from_int(84)); qdict_put_int(test_dict, "1.x", 84);
qdict_array_split(test_dict, &test_list); qdict_array_split(test_dict, &test_list);
@ -472,38 +472,38 @@ static void qdict_array_entries_test(void)
g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
qdict_put(dict, "bar", qint_from_int(0)); qdict_put_int(dict, "bar", 0);
qdict_put(dict, "baz.0", qint_from_int(0)); qdict_put_int(dict, "baz.0", 0);
g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
qdict_put(dict, "foo.1", qint_from_int(0)); qdict_put_int(dict, "foo.1", 0);
g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
qdict_put(dict, "foo.0", qint_from_int(0)); qdict_put_int(dict, "foo.0", 0);
g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2);
qdict_put(dict, "foo.bar", qint_from_int(0)); qdict_put_int(dict, "foo.bar", 0);
g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
qdict_del(dict, "foo.bar"); qdict_del(dict, "foo.bar");
qdict_put(dict, "foo.2.a", qint_from_int(0)); qdict_put_int(dict, "foo.2.a", 0);
qdict_put(dict, "foo.2.b", qint_from_int(0)); qdict_put_int(dict, "foo.2.b", 0);
qdict_put(dict, "foo.2.c", qint_from_int(0)); qdict_put_int(dict, "foo.2.c", 0);
g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL); g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
QDECREF(dict); QDECREF(dict);
dict = qdict_new(); dict = qdict_new();
qdict_put(dict, "1", qint_from_int(0)); qdict_put_int(dict, "1", 0);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL); g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
qdict_put(dict, "0", qint_from_int(0)); qdict_put_int(dict, "0", 0);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2); g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2);
qdict_put(dict, "bar", qint_from_int(0)); qdict_put_int(dict, "bar", 0);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL); g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
qdict_del(dict, "bar"); qdict_del(dict, "bar");
qdict_put(dict, "2.a", qint_from_int(0)); qdict_put_int(dict, "2.a", 0);
qdict_put(dict, "2.b", qint_from_int(0)); qdict_put_int(dict, "2.b", 0);
qdict_put(dict, "2.c", qint_from_int(0)); qdict_put_int(dict, "2.c", 0);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3); g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
QDECREF(dict); QDECREF(dict);
@ -529,7 +529,7 @@ static void qdict_join_test(void)
/* First iteration: Test movement */ /* First iteration: Test movement */
/* Second iteration: Test empty source and non-empty destination */ /* Second iteration: Test empty source and non-empty destination */
qdict_put(dict2, "foo", qint_from_int(42)); qdict_put_int(dict2, "foo", 42);
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
qdict_join(dict1, dict2, overwrite); qdict_join(dict1, dict2, overwrite);
@ -541,7 +541,7 @@ static void qdict_join_test(void)
} }
/* Test non-empty source and destination without conflict */ /* Test non-empty source and destination without conflict */
qdict_put(dict2, "bar", qint_from_int(23)); qdict_put_int(dict2, "bar", 23);
qdict_join(dict1, dict2, overwrite); qdict_join(dict1, dict2, overwrite);
@ -552,14 +552,14 @@ static void qdict_join_test(void)
g_assert(qdict_get_int(dict1, "bar") == 23); g_assert(qdict_get_int(dict1, "bar") == 23);
/* Test conflict */ /* Test conflict */
qdict_put(dict2, "foo", qint_from_int(84)); qdict_put_int(dict2, "foo", 84);
qdict_join(dict1, dict2, overwrite); qdict_join(dict1, dict2, overwrite);
g_assert(qdict_size(dict1) == 2); g_assert(qdict_size(dict1) == 2);
g_assert(qdict_size(dict2) == !overwrite); g_assert(qdict_size(dict2) == !overwrite);
g_assert(qdict_get_int(dict1, "foo") == overwrite ? 84 : 42); g_assert(qdict_get_int(dict1, "foo") == (overwrite ? 84 : 42));
g_assert(qdict_get_int(dict1, "bar") == 23); g_assert(qdict_get_int(dict1, "bar") == 23);
if (!overwrite) { if (!overwrite) {
@ -594,15 +594,15 @@ static void qdict_crumple_test_recursive(void)
QList *rules; QList *rules;
src = qdict_new(); src = qdict_new();
qdict_put(src, "vnc.listen.addr", qstring_from_str("127.0.0.1")); qdict_put_str(src, "vnc.listen.addr", "127.0.0.1");
qdict_put(src, "vnc.listen.port", qstring_from_str("5901")); qdict_put_str(src, "vnc.listen.port", "5901");
qdict_put(src, "vnc.acl.rules.0.match", qstring_from_str("fred")); qdict_put_str(src, "vnc.acl.rules.0.match", "fred");
qdict_put(src, "vnc.acl.rules.0.policy", qstring_from_str("allow")); qdict_put_str(src, "vnc.acl.rules.0.policy", "allow");
qdict_put(src, "vnc.acl.rules.1.match", qstring_from_str("bob")); qdict_put_str(src, "vnc.acl.rules.1.match", "bob");
qdict_put(src, "vnc.acl.rules.1.policy", qstring_from_str("deny")); qdict_put_str(src, "vnc.acl.rules.1.policy", "deny");
qdict_put(src, "vnc.acl.default", qstring_from_str("deny")); qdict_put_str(src, "vnc.acl.default", "deny");
qdict_put(src, "vnc.acl..name", qstring_from_str("acl0")); qdict_put_str(src, "vnc.acl..name", "acl0");
qdict_put(src, "vnc.acl.rule..name", qstring_from_str("acl0")); qdict_put_str(src, "vnc.acl.rule..name", "acl0");
dst = qobject_to_qdict(qdict_crumple(src, &error_abort)); dst = qobject_to_qdict(qdict_crumple(src, &error_abort));
g_assert(dst); g_assert(dst);
@ -669,8 +669,8 @@ static void qdict_crumple_test_bad_inputs(void)
src = qdict_new(); src = qdict_new();
/* rule.0 can't be both a string and a dict */ /* rule.0 can't be both a string and a dict */
qdict_put(src, "rule.0", qstring_from_str("fred")); qdict_put_str(src, "rule.0", "fred");
qdict_put(src, "rule.0.policy", qstring_from_str("allow")); qdict_put_str(src, "rule.0.policy", "allow");
g_assert(qdict_crumple(src, &error) == NULL); g_assert(qdict_crumple(src, &error) == NULL);
g_assert(error != NULL); g_assert(error != NULL);
@ -680,8 +680,8 @@ static void qdict_crumple_test_bad_inputs(void)
src = qdict_new(); src = qdict_new();
/* rule can't be both a list and a dict */ /* rule can't be both a list and a dict */
qdict_put(src, "rule.0", qstring_from_str("fred")); qdict_put_str(src, "rule.0", "fred");
qdict_put(src, "rule.a", qstring_from_str("allow")); qdict_put_str(src, "rule.a", "allow");
g_assert(qdict_crumple(src, &error) == NULL); g_assert(qdict_crumple(src, &error) == NULL);
g_assert(error != NULL); g_assert(error != NULL);
@ -692,7 +692,7 @@ static void qdict_crumple_test_bad_inputs(void)
src = qdict_new(); src = qdict_new();
/* The input should be flat, ie no dicts or lists */ /* The input should be flat, ie no dicts or lists */
qdict_put(src, "rule.a", qdict_new()); qdict_put(src, "rule.a", qdict_new());
qdict_put(src, "rule.b", qstring_from_str("allow")); qdict_put_str(src, "rule.b", "allow");
g_assert(qdict_crumple(src, &error) == NULL); g_assert(qdict_crumple(src, &error) == NULL);
g_assert(error != NULL); g_assert(error != NULL);
@ -702,8 +702,8 @@ static void qdict_crumple_test_bad_inputs(void)
src = qdict_new(); src = qdict_new();
/* List indexes must not have gaps */ /* List indexes must not have gaps */
qdict_put(src, "rule.0", qstring_from_str("deny")); qdict_put_str(src, "rule.0", "deny");
qdict_put(src, "rule.3", qstring_from_str("allow")); qdict_put_str(src, "rule.3", "allow");
g_assert(qdict_crumple(src, &error) == NULL); g_assert(qdict_crumple(src, &error) == NULL);
g_assert(error != NULL); g_assert(error != NULL);
@ -713,8 +713,8 @@ static void qdict_crumple_test_bad_inputs(void)
src = qdict_new(); src = qdict_new();
/* List indexes must be in %zu format */ /* List indexes must be in %zu format */
qdict_put(src, "rule.0", qstring_from_str("deny")); qdict_put_str(src, "rule.0", "deny");
qdict_put(src, "rule.+1", qstring_from_str("allow")); qdict_put_str(src, "rule.+1", "allow");
g_assert(qdict_crumple(src, &error) == NULL); g_assert(qdict_crumple(src, &error) == NULL);
g_assert(error != NULL); g_assert(error != NULL);
@ -733,8 +733,8 @@ static void qdict_put_exists_test(void)
const char *key = "exists"; const char *key = "exists";
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
qdict_put(tests_dict, key, qint_from_int(1)); qdict_put_int(tests_dict, key, 1);
qdict_put(tests_dict, key, qint_from_int(2)); qdict_put_int(tests_dict, key, 2);
value = qdict_get_int(tests_dict, key); value = qdict_get_int(tests_dict, key);
g_assert(value == 2); g_assert(value == 2);

4
tests/check-qlist.c
View File

@ -74,7 +74,7 @@ static void qlist_destroy_test(void)
qlist = qlist_new(); qlist = qlist_new();
for (i = 0; i < 42; i++) for (i = 0; i < 42; i++)
qlist_append(qlist, qint_from_int(i)); qlist_append_int(qlist, i);
QDECREF(qlist); QDECREF(qlist);
} }
@ -103,7 +103,7 @@ static void qlist_iter_test(void)
qlist = qlist_new(); qlist = qlist_new();
for (i = 0; i < iter_max; i++) for (i = 0; i < iter_max; i++)
qlist_append(qlist, qint_from_int(i)); qlist_append_int(qlist, i);
iter_called = 0; iter_called = 0;
qlist_iter(qlist, iter_func, NULL); qlist_iter(qlist, iter_func, NULL);

4
tests/device-introspect-test.c
View File

@ -32,9 +32,9 @@ static QList *qom_list_types(const char *implements, bool abstract)
QList *ret; QList *ret;
QDict *args = qdict_new(); QDict *args = qdict_new();
qdict_put(args, "abstract", qbool_from_bool(abstract)); qdict_put_bool(args, "abstract", abstract);
if (implements) { if (implements) {
qdict_put(args, "implements", qstring_from_str(implements)); qdict_put_str(args, "implements", implements);
} }
resp = qmp("{'execute': 'qom-list-types'," resp = qmp("{'execute': 'qom-list-types',"
" 'arguments': %p }", args); " 'arguments': %p }", args);

8
tests/fdc-test.c
View File

@ -298,8 +298,8 @@ static void test_media_insert(void)
/* Insert media in drive. DSKCHK should not be reset until a step pulse /* Insert media in drive. DSKCHK should not be reset until a step pulse
* is sent. */ * is sent. */
qmp_discard_response("{'execute':'change', 'arguments':{" qmp_discard_response("{'execute':'blockdev-change-medium', 'arguments':{"
" 'device':'floppy0', 'target': %s, 'arg': 'raw' }}", " 'id':'floppy0', 'filename': %s, 'format': 'raw' }}",
test_image); test_image);
dir = inb(FLOPPY_BASE + reg_dir); dir = inb(FLOPPY_BASE + reg_dir);
@ -330,7 +330,7 @@ static void test_media_change(void)
/* Eject the floppy and check that DSKCHG is set. Reading it out doesn't /* Eject the floppy and check that DSKCHG is set. Reading it out doesn't
* reset the bit. */ * reset the bit. */
qmp_discard_response("{'execute':'eject', 'arguments':{" qmp_discard_response("{'execute':'eject', 'arguments':{"
" 'device':'floppy0' }}"); " 'id':'floppy0' }}");
dir = inb(FLOPPY_BASE + reg_dir); dir = inb(FLOPPY_BASE + reg_dir);
assert_bit_set(dir, DSKCHG); assert_bit_set(dir, DSKCHG);
@ -564,7 +564,7 @@ int main(int argc, char **argv)
/* Run the tests */ /* Run the tests */
g_test_init(&argc, &argv, NULL); g_test_init(&argc, &argv, NULL);
qtest_start(NULL); qtest_start("-device floppy,id=floppy0");
qtest_irq_intercept_in(global_qtest, "ioapic"); qtest_irq_intercept_in(global_qtest, "ioapic");
qtest_add_func("/fdc/cmos", test_cmos); qtest_add_func("/fdc/cmos", test_cmos);
qtest_add_func("/fdc/no_media_on_start", test_no_media_on_start); qtest_add_func("/fdc/no_media_on_start", test_no_media_on_start);

8
tests/libqtest.c
View File

@ -446,6 +446,14 @@ void qmp_fd_sendv(int fd, const char *fmt, va_list ap)
va_list ap_copy; va_list ap_copy;
QObject *qobj; QObject *qobj;
/* qobject_from_jsonv() silently eats leading 0xff as invalid
* JSON, but we want to test sending them over the wire to force
* resyncs */
if (*fmt == '\377') {
socket_send(fd, fmt, 1);
fmt++;
}
/* Going through qobject ensures we escape strings properly. /* Going through qobject ensures we escape strings properly.
* This seemingly unnecessary copy is required in case va_list * This seemingly unnecessary copy is required in case va_list
* is an array type. * is an array type.

5
tests/test-char.c
View File

@ -291,7 +291,7 @@ static void char_socket_test(void)
Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait"); Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait");
Chardev *chr_client; Chardev *chr_client;
QObject *addr; QObject *addr;
QDict *qdict, *data; QDict *qdict;
const char *port; const char *port;
SocketIdleData d = { .chr = chr }; SocketIdleData d = { .chr = chr };
CharBackend be; CharBackend be;
@ -306,8 +306,7 @@ static void char_socket_test(void)
addr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort); addr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort);
qdict = qobject_to_qdict(addr); qdict = qobject_to_qdict(addr);
data = qdict_get_qdict(qdict, "data"); port = qdict_get_str(qdict, "port");
port = qdict_get_str(data, "port");
tmp = g_strdup_printf("tcp:127.0.0.1:%s", port); tmp = g_strdup_printf("tcp:127.0.0.1:%s", port);
QDECREF(qdict); QDECREF(qdict);

52
tests/test-io-channel-socket.c
View File

@ -125,12 +125,12 @@ static void test_io_channel_setup_sync(SocketAddress *listen_addr,
lioc = qio_channel_socket_new(); lioc = qio_channel_socket_new();
qio_channel_socket_listen_sync(lioc, listen_addr, &error_abort); qio_channel_socket_listen_sync(lioc, listen_addr, &error_abort);
if (listen_addr->type == SOCKET_ADDRESS_KIND_INET) { if (listen_addr->type == SOCKET_ADDRESS_TYPE_INET) {
SocketAddress *laddr = qio_channel_socket_get_local_address( SocketAddress *laddr = qio_channel_socket_get_local_address(
lioc, &error_abort); lioc, &error_abort);
g_free(connect_addr->u.inet.data->port); g_free(connect_addr->u.inet.port);
connect_addr->u.inet.data->port = g_strdup(laddr->u.inet.data->port); connect_addr->u.inet.port = g_strdup(laddr->u.inet.port);
qapi_free_SocketAddress(laddr); qapi_free_SocketAddress(laddr);
} }
@ -186,12 +186,12 @@ static void test_io_channel_setup_async(SocketAddress *listen_addr,
g_assert(!data.err); g_assert(!data.err);
if (listen_addr->type == SOCKET_ADDRESS_KIND_INET) { if (listen_addr->type == SOCKET_ADDRESS_TYPE_INET) {
SocketAddress *laddr = qio_channel_socket_get_local_address( SocketAddress *laddr = qio_channel_socket_get_local_address(
lioc, &error_abort); lioc, &error_abort);
g_free(connect_addr->u.inet.data->port); g_free(connect_addr->u.inet.port);
connect_addr->u.inet.data->port = g_strdup(laddr->u.inet.data->port); connect_addr->u.inet.port = g_strdup(laddr->u.inet.port);
qapi_free_SocketAddress(laddr); qapi_free_SocketAddress(laddr);
} }
@ -300,16 +300,14 @@ static void test_io_channel_ipv4(bool async)
SocketAddress *listen_addr = g_new0(SocketAddress, 1); SocketAddress *listen_addr = g_new0(SocketAddress, 1);
SocketAddress *connect_addr = g_new0(SocketAddress, 1); SocketAddress *connect_addr = g_new0(SocketAddress, 1);
listen_addr->type = SOCKET_ADDRESS_KIND_INET; listen_addr->type = SOCKET_ADDRESS_TYPE_INET;
listen_addr->u.inet.data = g_new(InetSocketAddress, 1); listen_addr->u.inet = (InetSocketAddress) {
*listen_addr->u.inet.data = (InetSocketAddress) {
.host = g_strdup("127.0.0.1"), .host = g_strdup("127.0.0.1"),
.port = NULL, /* Auto-select */ .port = NULL, /* Auto-select */
}; };
connect_addr->type = SOCKET_ADDRESS_KIND_INET; connect_addr->type = SOCKET_ADDRESS_TYPE_INET;
connect_addr->u.inet.data = g_new(InetSocketAddress, 1); connect_addr->u.inet = (InetSocketAddress) {
*connect_addr->u.inet.data = (InetSocketAddress) {
.host = g_strdup("127.0.0.1"), .host = g_strdup("127.0.0.1"),
.port = NULL, /* Filled in later */ .port = NULL, /* Filled in later */
}; };
@ -338,16 +336,14 @@ static void test_io_channel_ipv6(bool async)
SocketAddress *listen_addr = g_new0(SocketAddress, 1); SocketAddress *listen_addr = g_new0(SocketAddress, 1);
SocketAddress *connect_addr = g_new0(SocketAddress, 1); SocketAddress *connect_addr = g_new0(SocketAddress, 1);
listen_addr->type = SOCKET_ADDRESS_KIND_INET; listen_addr->type = SOCKET_ADDRESS_TYPE_INET;
listen_addr->u.inet.data = g_new(InetSocketAddress, 1); listen_addr->u.inet = (InetSocketAddress) {
*listen_addr->u.inet.data = (InetSocketAddress) {
.host = g_strdup("::1"), .host = g_strdup("::1"),
.port = NULL, /* Auto-select */ .port = NULL, /* Auto-select */
}; };
connect_addr->type = SOCKET_ADDRESS_KIND_INET; connect_addr->type = SOCKET_ADDRESS_TYPE_INET;
connect_addr->u.inet.data = g_new(InetSocketAddress, 1); connect_addr->u.inet = (InetSocketAddress) {
*connect_addr->u.inet.data = (InetSocketAddress) {
.host = g_strdup("::1"), .host = g_strdup("::1"),
.port = NULL, /* Filled in later */ .port = NULL, /* Filled in later */
}; };
@ -378,13 +374,11 @@ static void test_io_channel_unix(bool async)
SocketAddress *connect_addr = g_new0(SocketAddress, 1); SocketAddress *connect_addr = g_new0(SocketAddress, 1);
#define TEST_SOCKET "test-io-channel-socket.sock" #define TEST_SOCKET "test-io-channel-socket.sock"
listen_addr->type = SOCKET_ADDRESS_KIND_UNIX; listen_addr->type = SOCKET_ADDRESS_TYPE_UNIX;
listen_addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); listen_addr->u.q_unix.path = g_strdup(TEST_SOCKET);
listen_addr->u.q_unix.data->path = g_strdup(TEST_SOCKET);
connect_addr->type = SOCKET_ADDRESS_KIND_UNIX; connect_addr->type = SOCKET_ADDRESS_TYPE_UNIX;
connect_addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); connect_addr->u.q_unix.path = g_strdup(TEST_SOCKET);
connect_addr->u.q_unix.data->path = g_strdup(TEST_SOCKET);
test_io_channel(async, listen_addr, connect_addr, true); test_io_channel(async, listen_addr, connect_addr, true);
@ -427,13 +421,11 @@ static void test_io_channel_unix_fd_pass(void)
fdsend[1] = testfd; fdsend[1] = testfd;
fdsend[2] = testfd; fdsend[2] = testfd;
listen_addr->type = SOCKET_ADDRESS_KIND_UNIX; listen_addr->type = SOCKET_ADDRESS_TYPE_UNIX;
listen_addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); listen_addr->u.q_unix.path = g_strdup(TEST_SOCKET);
listen_addr->u.q_unix.data->path = g_strdup(TEST_SOCKET);
connect_addr->type = SOCKET_ADDRESS_KIND_UNIX; connect_addr->type = SOCKET_ADDRESS_TYPE_UNIX;
connect_addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); connect_addr->u.q_unix.path = g_strdup(TEST_SOCKET);
connect_addr->u.q_unix.data->path = g_strdup(TEST_SOCKET);
test_io_channel_setup_sync(listen_addr, connect_addr, &src, &dst); test_io_channel_setup_sync(listen_addr, connect_addr, &src, &dst);

4
tests/test-keyval.c
View File

@ -628,6 +628,7 @@ static void test_keyval_visit_alternate(void)
visit_type_AltNumStr(v, "a", &ans, &error_abort); visit_type_AltNumStr(v, "a", &ans, &error_abort);
g_assert_cmpint(ans->type, ==, QTYPE_QSTRING); g_assert_cmpint(ans->type, ==, QTYPE_QSTRING);
g_assert_cmpstr(ans->u.s, ==, "1"); g_assert_cmpstr(ans->u.s, ==, "1");
qapi_free_AltNumStr(ans);
visit_type_AltNumInt(v, "a", &ani, &err); visit_type_AltNumInt(v, "a", &ani, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
visit_end_struct(v, NULL); visit_end_struct(v, NULL);
@ -651,9 +652,12 @@ static void test_keyval_visit_any(void)
g_assert(qlist); g_assert(qlist);
qstr = qobject_to_qstring(qlist_pop(qlist)); qstr = qobject_to_qstring(qlist_pop(qlist));
g_assert_cmpstr(qstring_get_str(qstr), ==, "null"); g_assert_cmpstr(qstring_get_str(qstr), ==, "null");
QDECREF(qstr);
qstr = qobject_to_qstring(qlist_pop(qlist)); qstr = qobject_to_qstring(qlist_pop(qlist));
g_assert_cmpstr(qstring_get_str(qstr), ==, "1"); g_assert_cmpstr(qstring_get_str(qstr), ==, "1");
g_assert(qlist_empty(qlist)); g_assert(qlist_empty(qlist));
QDECREF(qstr);
qobject_decref(any);
visit_check_struct(v, &error_abort); visit_check_struct(v, &error_abort);
visit_end_struct(v, NULL); visit_end_struct(v, NULL);
visit_free(v); visit_free(v);

4
tests/test-qemu-opts.c
View File

@ -299,7 +299,7 @@ static void test_qemu_opt_get_size(void)
dict = qdict_new(); dict = qdict_new();
g_assert(dict != NULL); g_assert(dict != NULL);
qdict_put(dict, "size1", qstring_from_str("10")); qdict_put_str(dict, "size1", "10");
qemu_opts_absorb_qdict(opts, dict, &error_abort); qemu_opts_absorb_qdict(opts, dict, &error_abort);
g_assert(error_abort == NULL); g_assert(error_abort == NULL);
@ -309,7 +309,7 @@ static void test_qemu_opt_get_size(void)
g_assert(opt == 10); g_assert(opt == 10);
/* reset value */ /* reset value */
qdict_put(dict, "size1", qstring_from_str("15")); qdict_put_str(dict, "size1", "15");
qemu_opts_absorb_qdict(opts, dict, &error_abort); qemu_opts_absorb_qdict(opts, dict, &error_abort);
g_assert(error_abort == NULL); g_assert(error_abort == NULL);

37
tests/test-qga.c
View File

@ -146,14 +146,30 @@ static void test_qga_sync_delimited(gconstpointer fix)
QDict *ret; QDict *ret;
gchar *cmd; gchar *cmd;
cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited'," cmd = g_strdup_printf("\xff{'execute': 'guest-sync-delimited',"
" 'arguments': {'id': %u } }", 0xff, r); " 'arguments': {'id': %u } }", r);
qmp_fd_send(fixture->fd, cmd); qmp_fd_send(fixture->fd, cmd);
g_free(cmd); g_free(cmd);
/*
* Read and ignore garbage until resynchronized.
*
* Note that the full reset sequence would involve checking the
* response of guest-sync-delimited and repeating the loop if
* 'id' field of the response does not match the 'id' field of
* the request. Testing this fully would require inserting
* garbage in the response stream and is left as a future test
* to implement.
*
* TODO: The server shouldn't emit so much garbage (among other
* things, it loudly complains about the client's \xff being
* invalid JSON, even though it is a documented part of the
* handshake.
*/
do {
v = read(fixture->fd, &c, 1); v = read(fixture->fd, &c, 1);
g_assert_cmpint(v, ==, 1); g_assert_cmpint(v, ==, 1);
g_assert_cmpint(c, ==, 0xff); } while (c != 0xff);
ret = qmp_fd_receive(fixture->fd); ret = qmp_fd_receive(fixture->fd);
g_assert_nonnull(ret); g_assert_nonnull(ret);
@ -172,8 +188,19 @@ static void test_qga_sync(gconstpointer fix)
QDict *ret; QDict *ret;
gchar *cmd; gchar *cmd;
cmd = g_strdup_printf("%c{'execute': 'guest-sync'," /*
" 'arguments': {'id': %u } }", 0xff, r); * TODO guest-sync is inherently limited: we cannot distinguish
* failure caused by reacting to garbage on the wire prior to this
* command, from failure of this actual command. Clients are
* supposed to be able to send a raw '\xff' byte to at least
* re-synchronize the server's parser prior to this command, but
* we are not in a position to test that here because (at least
* for now) it causes the server to issue an error message about
* invalid JSON. Testing of '\xff' handling is done in
* guest-sync-delimited instead.
*/
cmd = g_strdup_printf("{'execute': 'guest-sync',"
" 'arguments': {'id': %u } }", r);
ret = qmp_fd(fixture->fd, cmd); ret = qmp_fd(fixture->fd, cmd);
g_free(cmd); g_free(cmd);

30
tests/test-qmp-commands.c
View File

@ -94,7 +94,7 @@ static void test_dispatch_cmd(void)
QDict *req = qdict_new(); QDict *req = qdict_new();
QObject *resp; QObject *resp;
qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd"))); qdict_put_str(req, "execute", "user_def_cmd");
resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); resp = qmp_dispatch(&qmp_commands, QOBJECT(req));
assert(resp != NULL); assert(resp != NULL);
@ -111,7 +111,7 @@ static void test_dispatch_cmd_failure(void)
QDict *args = qdict_new(); QDict *args = qdict_new();
QObject *resp; QObject *resp;
qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); qdict_put_str(req, "execute", "user_def_cmd2");
resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); resp = qmp_dispatch(&qmp_commands, QOBJECT(req));
assert(resp != NULL); assert(resp != NULL);
@ -122,10 +122,10 @@ static void test_dispatch_cmd_failure(void)
/* check that with extra arguments it throws an error */ /* check that with extra arguments it throws an error */
req = qdict_new(); req = qdict_new();
qdict_put(args, "a", qint_from_int(66)); qdict_put_int(args, "a", 66);
qdict_put(req, "arguments", args); qdict_put(req, "arguments", args);
qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd"))); qdict_put_str(req, "execute", "user_def_cmd");
resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); resp = qmp_dispatch(&qmp_commands, QOBJECT(req));
assert(resp != NULL); assert(resp != NULL);
@ -164,14 +164,14 @@ static void test_dispatch_cmd_io(void)
QDict *ret_dict_dict2, *ret_dict_dict2_userdef; QDict *ret_dict_dict2, *ret_dict_dict2_userdef;
QInt *ret3; QInt *ret3;
qdict_put_obj(ud1a, "integer", QOBJECT(qint_from_int(42))); qdict_put_int(ud1a, "integer", 42);
qdict_put_obj(ud1a, "string", QOBJECT(qstring_from_str("hello"))); qdict_put_str(ud1a, "string", "hello");
qdict_put_obj(ud1b, "integer", QOBJECT(qint_from_int(422))); qdict_put_int(ud1b, "integer", 422);
qdict_put_obj(ud1b, "string", QOBJECT(qstring_from_str("hello2"))); qdict_put_str(ud1b, "string", "hello2");
qdict_put_obj(args, "ud1a", QOBJECT(ud1a)); qdict_put(args, "ud1a", ud1a);
qdict_put_obj(args, "ud1b", QOBJECT(ud1b)); qdict_put(args, "ud1b", ud1b);
qdict_put_obj(req, "arguments", QOBJECT(args)); qdict_put(req, "arguments", args);
qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); qdict_put_str(req, "execute", "user_def_cmd2");
ret = qobject_to_qdict(test_qmp_dispatch(req)); ret = qobject_to_qdict(test_qmp_dispatch(req));
@ -190,9 +190,9 @@ static void test_dispatch_cmd_io(void)
assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4")); assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4"));
QDECREF(ret); QDECREF(ret);
qdict_put(args3, "a", qint_from_int(66)); qdict_put_int(args3, "a", 66);
qdict_put(req, "arguments", args3); qdict_put(req, "arguments", args3);
qdict_put(req, "execute", qstring_from_str("guest-get-time")); qdict_put_str(req, "execute", "guest-get-time");
ret3 = qobject_to_qint(test_qmp_dispatch(req)); ret3 = qobject_to_qint(test_qmp_dispatch(req));
assert(qint_get_int(ret3) == 66); assert(qint_get_int(ret3) == 66);
@ -244,7 +244,7 @@ static void test_dealloc_partial(void)
Visitor *v; Visitor *v;
ud2_dict = qdict_new(); ud2_dict = qdict_new();
qdict_put_obj(ud2_dict, "string0", QOBJECT(qstring_from_str(text))); qdict_put_str(ud2_dict, "string0", text);
v = qobject_input_visitor_new(QOBJECT(ud2_dict)); v = qobject_input_visitor_new(QOBJECT(ud2_dict));
visit_type_UserDefTwo(v, NULL, &ud2, &err); visit_type_UserDefTwo(v, NULL, &ud2, &err);

30
tests/test-qmp-event.c
View File

@ -153,7 +153,7 @@ static void test_event_a(TestEventData *data,
{ {
QDict *d; QDict *d;
d = data->expect; d = data->expect;
qdict_put(d, "event", qstring_from_str("EVENT_A")); qdict_put_str(d, "event", "EVENT_A");
qapi_event_send_event_a(&error_abort); qapi_event_send_event_a(&error_abort);
} }
@ -162,7 +162,7 @@ static void test_event_b(TestEventData *data,
{ {
QDict *d; QDict *d;
d = data->expect; d = data->expect;
qdict_put(d, "event", qstring_from_str("EVENT_B")); qdict_put_str(d, "event", "EVENT_B");
qapi_event_send_event_b(&error_abort); qapi_event_send_event_b(&error_abort);
} }
@ -177,16 +177,16 @@ static void test_event_c(TestEventData *data,
b.has_enum1 = false; b.has_enum1 = false;
d_b = qdict_new(); d_b = qdict_new();
qdict_put(d_b, "integer", qint_from_int(2)); qdict_put_int(d_b, "integer", 2);
qdict_put(d_b, "string", qstring_from_str("test1")); qdict_put_str(d_b, "string", "test1");
d_data = qdict_new(); d_data = qdict_new();
qdict_put(d_data, "a", qint_from_int(1)); qdict_put_int(d_data, "a", 1);
qdict_put(d_data, "b", d_b); qdict_put(d_data, "b", d_b);
qdict_put(d_data, "c", qstring_from_str("test2")); qdict_put_str(d_data, "c", "test2");
d = data->expect; d = data->expect;
qdict_put(d, "event", qstring_from_str("EVENT_C")); qdict_put_str(d, "event", "EVENT_C");
qdict_put(d, "data", d_data); qdict_put(d, "data", d_data);
qapi_event_send_event_c(true, 1, true, &b, "test2", &error_abort); qapi_event_send_event_c(true, 1, true, &b, "test2", &error_abort);
@ -213,22 +213,22 @@ static void test_event_d(TestEventData *data,
a.enum2 = ENUM_ONE_VALUE2; a.enum2 = ENUM_ONE_VALUE2;
d_struct1 = qdict_new(); d_struct1 = qdict_new();
qdict_put(d_struct1, "integer", qint_from_int(2)); qdict_put_int(d_struct1, "integer", 2);
qdict_put(d_struct1, "string", qstring_from_str("test1")); qdict_put_str(d_struct1, "string", "test1");
qdict_put(d_struct1, "enum1", qstring_from_str("value1")); qdict_put_str(d_struct1, "enum1", "value1");
d_a = qdict_new(); d_a = qdict_new();
qdict_put(d_a, "struct1", d_struct1); qdict_put(d_a, "struct1", d_struct1);
qdict_put(d_a, "string", qstring_from_str("test2")); qdict_put_str(d_a, "string", "test2");
qdict_put(d_a, "enum2", qstring_from_str("value2")); qdict_put_str(d_a, "enum2", "value2");
d_data = qdict_new(); d_data = qdict_new();
qdict_put(d_data, "a", d_a); qdict_put(d_data, "a", d_a);
qdict_put(d_data, "b", qstring_from_str("test3")); qdict_put_str(d_data, "b", "test3");
qdict_put(d_data, "enum3", qstring_from_str("value3")); qdict_put_str(d_data, "enum3", "value3");
d = data->expect; d = data->expect;
qdict_put(d, "event", qstring_from_str("EVENT_D")); qdict_put_str(d, "event", "EVENT_D");
qdict_put(d, "data", d_data); qdict_put(d, "data", d_data);
qapi_event_send_event_d(&a, "test3", false, NULL, true, ENUM_ONE_VALUE3, qapi_event_send_event_d(&a, "test3", false, NULL, true, ENUM_ONE_VALUE3,

6
tests/test-qobject-output-visitor.c
View File

@ -343,9 +343,9 @@ static void test_visitor_out_any(TestOutputVisitorData *data,
visitor_reset(data); visitor_reset(data);
qdict = qdict_new(); qdict = qdict_new();
qdict_put(qdict, "integer", qint_from_int(-42)); qdict_put_int(qdict, "integer", -42);
qdict_put(qdict, "boolean", qbool_from_bool(true)); qdict_put_bool(qdict, "boolean", true);
qdict_put(qdict, "string", qstring_from_str("foo")); qdict_put_str(qdict, "string", "foo");
qobj = QOBJECT(qdict); qobj = QOBJECT(qdict);
visit_type_any(data->ov, NULL, &qobj, &error_abort); visit_type_any(data->ov, NULL, &qobj, &error_abort);
qobject_decref(qobj); qobject_decref(qobj);

5
ui/vnc-auth-sasl.c
View File

@ -510,12 +510,11 @@ vnc_socket_ip_addr_string(QIOChannelSocket *ioc,
return NULL; return NULL;
} }
if (addr->type != SOCKET_ADDRESS_KIND_INET) { if (addr->type != SOCKET_ADDRESS_TYPE_INET) {
error_setg(errp, "Not an inet socket type"); error_setg(errp, "Not an inet socket type");
return NULL; return NULL;
} }
ret = g_strdup_printf("%s;%s", addr->u.inet.data->host, ret = g_strdup_printf("%s;%s", addr->u.inet.host, addr->u.inet.port);
addr->u.inet.data->port);
qapi_free_SocketAddress(addr); qapi_free_SocketAddress(addr);
return ret; return ret;
} }

68
ui/vnc.c
View File

@ -113,26 +113,26 @@ static void vnc_init_basic_info(SocketAddress *addr,
Error **errp) Error **errp)
{ {
switch (addr->type) { switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_TYPE_INET:
info->host = g_strdup(addr->u.inet.data->host); info->host = g_strdup(addr->u.inet.host);
info->service = g_strdup(addr->u.inet.data->port); info->service = g_strdup(addr->u.inet.port);
if (addr->u.inet.data->ipv6) { if (addr->u.inet.ipv6) {
info->family = NETWORK_ADDRESS_FAMILY_IPV6; info->family = NETWORK_ADDRESS_FAMILY_IPV6;
} else { } else {
info->family = NETWORK_ADDRESS_FAMILY_IPV4; info->family = NETWORK_ADDRESS_FAMILY_IPV4;
} }
break; break;
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
info->host = g_strdup(""); info->host = g_strdup("");
info->service = g_strdup(addr->u.q_unix.data->path); info->service = g_strdup(addr->u.q_unix.path);
info->family = NETWORK_ADDRESS_FAMILY_UNIX; info->family = NETWORK_ADDRESS_FAMILY_UNIX;
break; break;
case SOCKET_ADDRESS_KIND_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
case SOCKET_ADDRESS_KIND_FD: case SOCKET_ADDRESS_TYPE_FD:
error_setg(errp, "Unsupported socket address type %s", error_setg(errp, "Unsupported socket address type %s",
SocketAddressKind_lookup[addr->type]); SocketAddressType_lookup[addr->type]);
break; break;
default: default:
abort(); abort();
@ -398,26 +398,26 @@ VncInfo *qmp_query_vnc(Error **errp)
} }
switch (addr->type) { switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_TYPE_INET:
info->host = g_strdup(addr->u.inet.data->host); info->host = g_strdup(addr->u.inet.host);
info->service = g_strdup(addr->u.inet.data->port); info->service = g_strdup(addr->u.inet.port);
if (addr->u.inet.data->ipv6) { if (addr->u.inet.ipv6) {
info->family = NETWORK_ADDRESS_FAMILY_IPV6; info->family = NETWORK_ADDRESS_FAMILY_IPV6;
} else { } else {
info->family = NETWORK_ADDRESS_FAMILY_IPV4; info->family = NETWORK_ADDRESS_FAMILY_IPV4;
} }
break; break;
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
info->host = g_strdup(""); info->host = g_strdup("");
info->service = g_strdup(addr->u.q_unix.data->path); info->service = g_strdup(addr->u.q_unix.path);
info->family = NETWORK_ADDRESS_FAMILY_UNIX; info->family = NETWORK_ADDRESS_FAMILY_UNIX;
break; break;
case SOCKET_ADDRESS_KIND_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
case SOCKET_ADDRESS_KIND_FD: case SOCKET_ADDRESS_TYPE_FD:
error_setg(errp, "Unsupported socket address type %s", error_setg(errp, "Unsupported socket address type %s",
SocketAddressKind_lookup[addr->type]); SocketAddressType_lookup[addr->type]);
goto out_error; goto out_error;
default: default:
abort(); abort();
@ -3161,13 +3161,13 @@ static void vnc_display_print_local_addr(VncDisplay *vd)
return; return;
} }
if (addr->type != SOCKET_ADDRESS_KIND_INET) { if (addr->type != SOCKET_ADDRESS_TYPE_INET) {
qapi_free_SocketAddress(addr); qapi_free_SocketAddress(addr);
return; return;
} }
error_printf_unless_qmp("VNC server running on %s:%s\n", error_printf_unless_qmp("VNC server running on %s:%s\n",
addr->u.inet.data->host, addr->u.inet.host,
addr->u.inet.data->port); addr->u.inet.port);
qapi_free_SocketAddress(addr); qapi_free_SocketAddress(addr);
} }
@ -3423,9 +3423,8 @@ static int vnc_display_get_address(const char *addrstr,
addr = g_new0(SocketAddress, 1); addr = g_new0(SocketAddress, 1);
if (strncmp(addrstr, "unix:", 5) == 0) { if (strncmp(addrstr, "unix:", 5) == 0) {
addr->type = SOCKET_ADDRESS_KIND_UNIX; addr->type = SOCKET_ADDRESS_TYPE_UNIX;
addr->u.q_unix.data = g_new0(UnixSocketAddress, 1); addr->u.q_unix.path = g_strdup(addrstr + 5);
addr->u.q_unix.data->path = g_strdup(addrstr + 5);
if (websocket) { if (websocket) {
error_setg(errp, "UNIX sockets not supported with websock"); error_setg(errp, "UNIX sockets not supported with websock");
@ -3461,8 +3460,8 @@ static int vnc_display_get_address(const char *addrstr,
} }
} }
addr->type = SOCKET_ADDRESS_KIND_INET; addr->type = SOCKET_ADDRESS_TYPE_INET;
inet = addr->u.inet.data = g_new0(InetSocketAddress, 1); inet = &addr->u.inet;
if (addrstr[0] == '[' && addrstr[hostlen - 1] == ']') { if (addrstr[0] == '[' && addrstr[hostlen - 1] == ']') {
inet->host = g_strndup(addrstr + 1, hostlen - 2); inet->host = g_strndup(addrstr + 1, hostlen - 2);
} else { } else {
@ -3601,13 +3600,12 @@ static int vnc_display_get_addresses(QemuOpts *opts,
* address for websocket too * address for websocket too
*/ */
if (*retnsaddr == 1 && if (*retnsaddr == 1 &&
(*retsaddr)[0]->type == SOCKET_ADDRESS_KIND_INET && (*retsaddr)[0]->type == SOCKET_ADDRESS_TYPE_INET &&
wsaddr->type == SOCKET_ADDRESS_KIND_INET && wsaddr->type == SOCKET_ADDRESS_TYPE_INET &&
g_str_equal(wsaddr->u.inet.data->host, "") && g_str_equal(wsaddr->u.inet.host, "") &&
!g_str_equal((*retsaddr)[0]->u.inet.data->host, "")) { !g_str_equal((*retsaddr)[0]->u.inet.host, "")) {
g_free(wsaddr->u.inet.data->host); g_free(wsaddr->u.inet.host);
wsaddr->u.inet.data->host = wsaddr->u.inet.host = g_strdup((*retsaddr)[0]->u.inet.host);
g_strdup((*retsaddr)[0]->u.inet.data->host);
} }
*retwsaddr = g_renew(SocketAddress *, *retwsaddr, *retnwsaddr + 1); *retwsaddr = g_renew(SocketAddress *, *retwsaddr, *retnwsaddr + 1);
@ -3648,8 +3646,8 @@ static int vnc_display_connect(VncDisplay *vd,
error_setg(errp, "Expected a single address in reverse mode"); error_setg(errp, "Expected a single address in reverse mode");
return -1; return -1;
} }
/* TODO SOCKET_ADDRESS_KIND_FD when fd has AF_UNIX */ /* TODO SOCKET_ADDRESS_TYPE_FD when fd has AF_UNIX */
vd->is_unix = saddr[0]->type == SOCKET_ADDRESS_KIND_UNIX; vd->is_unix = saddr[0]->type == SOCKET_ADDRESS_TYPE_UNIX;
sioc = qio_channel_socket_new(); sioc = qio_channel_socket_new();
qio_channel_set_name(QIO_CHANNEL(sioc), "vnc-reverse"); qio_channel_set_name(QIO_CHANNEL(sioc), "vnc-reverse");
if (qio_channel_socket_connect_sync(sioc, saddr[0], errp) < 0) { if (qio_channel_socket_connect_sync(sioc, saddr[0], errp) < 0) {

6
util/qemu-option.c
View File

@ -1054,17 +1054,15 @@ void qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp)
QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict) QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
{ {
QemuOpt *opt; QemuOpt *opt;
QObject *val;
if (!qdict) { if (!qdict) {
qdict = qdict_new(); qdict = qdict_new();
} }
if (opts->id) { if (opts->id) {
qdict_put(qdict, "id", qstring_from_str(opts->id)); qdict_put_str(qdict, "id", opts->id);
} }
QTAILQ_FOREACH(opt, &opts->head, next) { QTAILQ_FOREACH(opt, &opts->head, next) {
val = QOBJECT(qstring_from_str(opt->str)); qdict_put_str(qdict, opt->name, opt->str);
qdict_put_obj(qdict, opt->name, val);
} }
return qdict; return qdict;
} }

181
util/qemu-sockets.c
View File

@ -22,6 +22,7 @@
#endif /* CONFIG_AF_VSOCK */ #endif /* CONFIG_AF_VSOCK */
#include "monitor/monitor.h" #include "monitor/monitor.h"
#include "qapi/clone-visitor.h"
#include "qapi/error.h" #include "qapi/error.h"
#include "qemu/sockets.h" #include "qemu/sockets.h"
#include "qemu/main-loop.h" #include "qemu/main-loop.h"
@ -578,16 +579,15 @@ err:
} }
/* compatibility wrapper */ /* compatibility wrapper */
InetSocketAddress *inet_parse(const char *str, Error **errp) int inet_parse(InetSocketAddress *addr, const char *str, Error **errp)
{ {
InetSocketAddress *addr;
const char *optstr, *h; const char *optstr, *h;
char host[65]; char host[65];
char port[33]; char port[33];
int to; int to;
int pos; int pos;
addr = g_new0(InetSocketAddress, 1); memset(addr, 0, sizeof(*addr));
/* parse address */ /* parse address */
if (str[0] == ':') { if (str[0] == ':') {
@ -595,20 +595,20 @@ InetSocketAddress *inet_parse(const char *str, Error **errp)
host[0] = '\0'; host[0] = '\0';
if (sscanf(str, ":%32[^,]%n", port, &pos) != 1) { if (sscanf(str, ":%32[^,]%n", port, &pos) != 1) {
error_setg(errp, "error parsing port in address '%s'", str); error_setg(errp, "error parsing port in address '%s'", str);
goto fail; return -1;
} }
} else if (str[0] == '[') { } else if (str[0] == '[') {
/* IPv6 addr */ /* IPv6 addr */
if (sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos) != 2) { if (sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos) != 2) {
error_setg(errp, "error parsing IPv6 address '%s'", str); error_setg(errp, "error parsing IPv6 address '%s'", str);
goto fail; return -1;
} }
addr->ipv6 = addr->has_ipv6 = true; addr->ipv6 = addr->has_ipv6 = true;
} else { } else {
/* hostname or IPv4 addr */ /* hostname or IPv4 addr */
if (sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos) != 2) { if (sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos) != 2) {
error_setg(errp, "error parsing address '%s'", str); error_setg(errp, "error parsing address '%s'", str);
goto fail; return -1;
} }
if (host[strspn(host, "0123456789.")] == '\0') { if (host[strspn(host, "0123456789.")] == '\0') {
addr->ipv4 = addr->has_ipv4 = true; addr->ipv4 = addr->has_ipv4 = true;
@ -626,7 +626,7 @@ InetSocketAddress *inet_parse(const char *str, Error **errp)
if (sscanf(h, "%d%n", &to, &pos) != 1 || if (sscanf(h, "%d%n", &to, &pos) != 1 ||
(h[pos] != '\0' && h[pos] != ',')) { (h[pos] != '\0' && h[pos] != ',')) {
error_setg(errp, "error parsing to= argument"); error_setg(errp, "error parsing to= argument");
goto fail; return -1;
} }
addr->has_to = true; addr->has_to = true;
addr->to = to; addr->to = to;
@ -637,11 +637,7 @@ InetSocketAddress *inet_parse(const char *str, Error **errp)
if (strstr(optstr, ",ipv6")) { if (strstr(optstr, ",ipv6")) {
addr->ipv6 = addr->has_ipv6 = true; addr->ipv6 = addr->has_ipv6 = true;
} }
return addr; return 0;
fail:
qapi_free_InetSocketAddress(addr);
return NULL;
} }
@ -656,13 +652,12 @@ fail:
int inet_connect(const char *str, Error **errp) int inet_connect(const char *str, Error **errp)
{ {
int sock = -1; int sock = -1;
InetSocketAddress *addr; InetSocketAddress *addr = g_new(InetSocketAddress, 1);
addr = inet_parse(str, errp); if (!inet_parse(addr, str, errp)) {
if (addr != NULL) {
sock = inet_connect_saddr(addr, NULL, NULL, errp); sock = inet_connect_saddr(addr, NULL, NULL, errp);
qapi_free_InetSocketAddress(addr);
} }
qapi_free_InetSocketAddress(addr);
return sock; return sock;
} }
@ -793,26 +788,25 @@ static int vsock_listen_saddr(VsockSocketAddress *vaddr,
return slisten; return slisten;
} }
static VsockSocketAddress *vsock_parse(const char *str, Error **errp) static int vsock_parse(VsockSocketAddress *addr, const char *str,
Error **errp)
{ {
VsockSocketAddress *addr = NULL;
char cid[33]; char cid[33];
char port[33]; char port[33];
int n; int n;
if (sscanf(str, "%32[^:]:%32[^,]%n", cid, port, &n) != 2) { if (sscanf(str, "%32[^:]:%32[^,]%n", cid, port, &n) != 2) {
error_setg(errp, "error parsing address '%s'", str); error_setg(errp, "error parsing address '%s'", str);
return NULL; return -1;
} }
if (str[n] != '\0') { if (str[n] != '\0') {
error_setg(errp, "trailing characters in address '%s'", str); error_setg(errp, "trailing characters in address '%s'", str);
return NULL; return -1;
} }
addr = g_new0(VsockSocketAddress, 1);
addr->cid = g_strdup(cid); addr->cid = g_strdup(cid);
addr->port = g_strdup(port); addr->port = g_strdup(port);
return addr; return 0;
} }
#else #else
static void vsock_unsupported(Error **errp) static void vsock_unsupported(Error **errp)
@ -835,10 +829,11 @@ static int vsock_listen_saddr(VsockSocketAddress *vaddr,
return -1; return -1;
} }
static VsockSocketAddress *vsock_parse(const char *str, Error **errp) static int vsock_parse(VsockSocketAddress *addr, const char *str,
Error **errp)
{ {
vsock_unsupported(errp); vsock_unsupported(errp);
return NULL; return -1;
} }
#endif /* CONFIG_AF_VSOCK */ #endif /* CONFIG_AF_VSOCK */
@ -1045,29 +1040,25 @@ SocketAddress *socket_parse(const char *str, Error **errp)
error_setg(errp, "invalid Unix socket address"); error_setg(errp, "invalid Unix socket address");
goto fail; goto fail;
} else { } else {
addr->type = SOCKET_ADDRESS_KIND_UNIX; addr->type = SOCKET_ADDRESS_TYPE_UNIX;
addr->u.q_unix.data = g_new(UnixSocketAddress, 1); addr->u.q_unix.path = g_strdup(str + 5);
addr->u.q_unix.data->path = g_strdup(str + 5);
} }
} else if (strstart(str, "fd:", NULL)) { } else if (strstart(str, "fd:", NULL)) {
if (str[3] == '\0') { if (str[3] == '\0') {
error_setg(errp, "invalid file descriptor address"); error_setg(errp, "invalid file descriptor address");
goto fail; goto fail;
} else { } else {
addr->type = SOCKET_ADDRESS_KIND_FD; addr->type = SOCKET_ADDRESS_TYPE_FD;
addr->u.fd.data = g_new(String, 1); addr->u.fd.str = g_strdup(str + 3);
addr->u.fd.data->str = g_strdup(str + 3);
} }
} else if (strstart(str, "vsock:", NULL)) { } else if (strstart(str, "vsock:", NULL)) {
addr->type = SOCKET_ADDRESS_KIND_VSOCK; addr->type = SOCKET_ADDRESS_TYPE_VSOCK;
addr->u.vsock.data = vsock_parse(str + strlen("vsock:"), errp); if (vsock_parse(&addr->u.vsock, str + strlen("vsock:"), errp)) {
if (addr->u.vsock.data == NULL) {
goto fail; goto fail;
} }
} else { } else {
addr->type = SOCKET_ADDRESS_KIND_INET; addr->type = SOCKET_ADDRESS_TYPE_INET;
addr->u.inet.data = inet_parse(str, errp); if (inet_parse(&addr->u.inet, str, errp)) {
if (addr->u.inet.data == NULL) {
goto fail; goto fail;
} }
} }
@ -1084,24 +1075,24 @@ int socket_connect(SocketAddress *addr, NonBlockingConnectHandler *callback,
int fd; int fd;
switch (addr->type) { switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_TYPE_INET:
fd = inet_connect_saddr(addr->u.inet.data, callback, opaque, errp); fd = inet_connect_saddr(&addr->u.inet, callback, opaque, errp);
break; break;
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
fd = unix_connect_saddr(addr->u.q_unix.data, callback, opaque, errp); fd = unix_connect_saddr(&addr->u.q_unix, callback, opaque, errp);
break; break;
case SOCKET_ADDRESS_KIND_FD: case SOCKET_ADDRESS_TYPE_FD:
fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp); fd = monitor_get_fd(cur_mon, addr->u.fd.str, errp);
if (fd >= 0 && callback) { if (fd >= 0 && callback) {
qemu_set_nonblock(fd); qemu_set_nonblock(fd);
callback(fd, NULL, opaque); callback(fd, NULL, opaque);
} }
break; break;
case SOCKET_ADDRESS_KIND_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
fd = vsock_connect_saddr(addr->u.vsock.data, callback, opaque, errp); fd = vsock_connect_saddr(&addr->u.vsock, callback, opaque, errp);
break; break;
default: default:
@ -1115,20 +1106,20 @@ int socket_listen(SocketAddress *addr, Error **errp)
int fd; int fd;
switch (addr->type) { switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_TYPE_INET:
fd = inet_listen_saddr(addr->u.inet.data, 0, false, errp); fd = inet_listen_saddr(&addr->u.inet, 0, false, errp);
break; break;
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
fd = unix_listen_saddr(addr->u.q_unix.data, false, errp); fd = unix_listen_saddr(&addr->u.q_unix, false, errp);
break; break;
case SOCKET_ADDRESS_KIND_FD: case SOCKET_ADDRESS_TYPE_FD:
fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp); fd = monitor_get_fd(cur_mon, addr->u.fd.str, errp);
break; break;
case SOCKET_ADDRESS_KIND_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
fd = vsock_listen_saddr(addr->u.vsock.data, errp); fd = vsock_listen_saddr(&addr->u.vsock, errp);
break; break;
default: default:
@ -1143,12 +1134,12 @@ void socket_listen_cleanup(int fd, Error **errp)
addr = socket_local_address(fd, errp); addr = socket_local_address(fd, errp);
if (addr->type == SOCKET_ADDRESS_KIND_UNIX if (addr->type == SOCKET_ADDRESS_TYPE_UNIX
&& addr->u.q_unix.data->path) { && addr->u.q_unix.path) {
if (unlink(addr->u.q_unix.data->path) < 0 && errno != ENOENT) { if (unlink(addr->u.q_unix.path) < 0 && errno != ENOENT) {
error_setg_errno(errp, errno, error_setg_errno(errp, errno,
"Failed to unlink socket %s", "Failed to unlink socket %s",
addr->u.q_unix.data->path); addr->u.q_unix.path);
} }
} }
@ -1160,13 +1151,13 @@ int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp)
int fd; int fd;
/* /*
* TODO SOCKET_ADDRESS_KIND_FD when fd is AF_INET or AF_INET6 * TODO SOCKET_ADDRESS_TYPE_FD when fd is AF_INET or AF_INET6
* (although other address families can do SOCK_DGRAM, too) * (although other address families can do SOCK_DGRAM, too)
*/ */
switch (remote->type) { switch (remote->type) {
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_TYPE_INET:
fd = inet_dgram_saddr(remote->u.inet.data, fd = inet_dgram_saddr(&remote->u.inet,
local ? local->u.inet.data : NULL, errp); local ? &local->u.inet : NULL, errp);
break; break;
default: default:
@ -1199,8 +1190,8 @@ socket_sockaddr_to_address_inet(struct sockaddr_storage *sa,
} }
addr = g_new0(SocketAddress, 1); addr = g_new0(SocketAddress, 1);
addr->type = SOCKET_ADDRESS_KIND_INET; addr->type = SOCKET_ADDRESS_TYPE_INET;
inet = addr->u.inet.data = g_new0(InetSocketAddress, 1); inet = &addr->u.inet;
inet->host = g_strdup(host); inet->host = g_strdup(host);
inet->port = g_strdup(serv); inet->port = g_strdup(serv);
if (sa->ss_family == AF_INET) { if (sa->ss_family == AF_INET) {
@ -1223,11 +1214,9 @@ socket_sockaddr_to_address_unix(struct sockaddr_storage *sa,
struct sockaddr_un *su = (struct sockaddr_un *)sa; struct sockaddr_un *su = (struct sockaddr_un *)sa;
addr = g_new0(SocketAddress, 1); addr = g_new0(SocketAddress, 1);
addr->type = SOCKET_ADDRESS_KIND_UNIX; addr->type = SOCKET_ADDRESS_TYPE_UNIX;
addr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
if (su->sun_path[0]) { if (su->sun_path[0]) {
addr->u.q_unix.data->path = g_strndup(su->sun_path, addr->u.q_unix.path = g_strndup(su->sun_path, sizeof(su->sun_path));
sizeof(su->sun_path));
} }
return addr; return addr;
@ -1245,8 +1234,8 @@ socket_sockaddr_to_address_vsock(struct sockaddr_storage *sa,
struct sockaddr_vm *svm = (struct sockaddr_vm *)sa; struct sockaddr_vm *svm = (struct sockaddr_vm *)sa;
addr = g_new0(SocketAddress, 1); addr = g_new0(SocketAddress, 1);
addr->type = SOCKET_ADDRESS_KIND_VSOCK; addr->type = SOCKET_ADDRESS_TYPE_VSOCK;
addr->u.vsock.data = vaddr = g_new0(VsockSocketAddress, 1); vaddr = &addr->u.vsock;
vaddr->cid = g_strdup_printf("%u", svm->svm_cid); vaddr->cid = g_strdup_printf("%u", svm->svm_cid);
vaddr->port = g_strdup_printf("%u", svm->svm_port); vaddr->port = g_strdup_printf("%u", svm->svm_port);
@ -1318,8 +1307,8 @@ char *socket_address_to_string(struct SocketAddress *addr, Error **errp)
InetSocketAddress *inet; InetSocketAddress *inet;
switch (addr->type) { switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_TYPE_INET:
inet = addr->u.inet.data; inet = &addr->u.inet;
if (strchr(inet->host, ':') == NULL) { if (strchr(inet->host, ':') == NULL) {
buf = g_strdup_printf("%s:%s", inet->host, inet->port); buf = g_strdup_printf("%s:%s", inet->host, inet->port);
} else { } else {
@ -1327,18 +1316,18 @@ char *socket_address_to_string(struct SocketAddress *addr, Error **errp)
} }
break; break;
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
buf = g_strdup(addr->u.q_unix.data->path); buf = g_strdup(addr->u.q_unix.path);
break; break;
case SOCKET_ADDRESS_KIND_FD: case SOCKET_ADDRESS_TYPE_FD:
buf = g_strdup(addr->u.fd.data->str); buf = g_strdup(addr->u.fd.str);
break; break;
case SOCKET_ADDRESS_KIND_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
buf = g_strdup_printf("%s:%s", buf = g_strdup_printf("%s:%s",
addr->u.vsock.data->cid, addr->u.vsock.cid,
addr->u.vsock.data->port); addr->u.vsock.port);
break; break;
default: default:
@ -1347,29 +1336,33 @@ char *socket_address_to_string(struct SocketAddress *addr, Error **errp)
return buf; return buf;
} }
SocketAddress *socket_address_crumple(SocketAddressFlat *addr_flat) SocketAddress *socket_address_flatten(SocketAddressLegacy *addr_legacy)
{ {
SocketAddress *addr = g_new(SocketAddress, 1); SocketAddress *addr = g_new(SocketAddress, 1);
switch (addr_flat->type) { if (!addr_legacy) {
case SOCKET_ADDRESS_FLAT_TYPE_INET: return NULL;
addr->type = SOCKET_ADDRESS_KIND_INET; }
addr->u.inet.data = QAPI_CLONE(InetSocketAddress,
&addr_flat->u.inet); switch (addr_legacy->type) {
case SOCKET_ADDRESS_LEGACY_KIND_INET:
addr->type = SOCKET_ADDRESS_TYPE_INET;
QAPI_CLONE_MEMBERS(InetSocketAddress, &addr->u.inet,
addr_legacy->u.inet.data);
break; break;
case SOCKET_ADDRESS_FLAT_TYPE_UNIX: case SOCKET_ADDRESS_LEGACY_KIND_UNIX:
addr->type = SOCKET_ADDRESS_KIND_UNIX; addr->type = SOCKET_ADDRESS_TYPE_UNIX;
addr->u.q_unix.data = QAPI_CLONE(UnixSocketAddress, QAPI_CLONE_MEMBERS(UnixSocketAddress, &addr->u.q_unix,
&addr_flat->u.q_unix); addr_legacy->u.q_unix.data);
break; break;
case SOCKET_ADDRESS_FLAT_TYPE_VSOCK: case SOCKET_ADDRESS_LEGACY_KIND_VSOCK:
addr->type = SOCKET_ADDRESS_KIND_VSOCK; addr->type = SOCKET_ADDRESS_TYPE_VSOCK;
addr->u.vsock.data = QAPI_CLONE(VsockSocketAddress, QAPI_CLONE_MEMBERS(VsockSocketAddress, &addr->u.vsock,
&addr_flat->u.vsock); addr_legacy->u.vsock.data);
break; break;
case SOCKET_ADDRESS_FLAT_TYPE_FD: case SOCKET_ADDRESS_LEGACY_KIND_FD:
addr->type = SOCKET_ADDRESS_KIND_FD; addr->type = SOCKET_ADDRESS_TYPE_FD;
addr->u.fd.data = QAPI_CLONE(String, &addr_flat->u.fd); QAPI_CLONE_MEMBERS(String, &addr->u.fd, addr_legacy->u.fd.data);
break; break;
default: default:
abort(); abort();