2016-02-08 21:08:51 +03:00
|
|
|
#include "qemu/osdep.h"
|
qapi: Implement deprecated-output=hide for QMP command results
This policy suppresses deprecated bits in output, and thus permits
"testing the future". Implement it for QMP command results. Example:
when QEMU is run with -compat deprecated-output=hide, then
{"execute": "query-cpus-fast"}
yields
{"return": [{"thread-id": 9805, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
instead of
{"return": [{"arch": "x86", "thread-id": 22436, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
Note the suppression of deprecated member "arch".
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20210318155519.1224118-4-armbru@redhat.com>
2021-03-18 18:55:11 +03:00
|
|
|
#include "qapi/compat-policy.h"
|
2018-02-01 14:18:35 +03:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2020-03-17 14:54:32 +03:00
|
|
|
#include "qapi/qmp/qjson.h"
|
2018-02-01 14:18:36 +03:00
|
|
|
#include "qapi/qmp/qnum.h"
|
2018-02-01 14:18:35 +03:00
|
|
|
#include "qapi/qmp/qstring.h"
|
2018-02-01 14:18:31 +03:00
|
|
|
#include "qapi/error.h"
|
2016-09-30 17:45:27 +03:00
|
|
|
#include "qapi/qobject-input-visitor.h"
|
2012-07-17 18:17:05 +04:00
|
|
|
#include "tests/test-qapi-types.h"
|
|
|
|
#include "tests/test-qapi-visit.h"
|
2018-02-11 12:36:05 +03:00
|
|
|
#include "test-qapi-commands.h"
|
2019-11-20 21:25:48 +03:00
|
|
|
#include "test-qapi-init-commands.h"
|
2011-07-19 23:50:45 +04:00
|
|
|
|
2017-03-03 15:32:25 +03:00
|
|
|
static QmpCommandList qmp_commands;
|
|
|
|
|
2021-03-23 12:40:21 +03:00
|
|
|
UserDefThree *qmp_test_cmd_return_def_three(Error **errp)
|
2018-07-03 18:56:35 +03:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-07-19 23:50:45 +04:00
|
|
|
void qmp_user_def_cmd(Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2018-05-11 20:15:59 +03:00
|
|
|
void qmp_test_flags_command(Error **errp)
|
2018-03-26 09:38:59 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2018-08-30 18:58:10 +03:00
|
|
|
void qmp_cmd_success_response(Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2020-10-05 18:58:49 +03:00
|
|
|
void qmp_coroutine_cmd(Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2016-03-18 01:48:27 +03:00
|
|
|
Empty2 *qmp_user_def_cmd0(Error **errp)
|
|
|
|
{
|
|
|
|
return g_new0(Empty2, 1);
|
|
|
|
}
|
|
|
|
|
2011-07-19 23:50:45 +04:00
|
|
|
void qmp_user_def_cmd1(UserDefOne * ud1, Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
qapi: Implement deprecated-output=hide for QMP command results
This policy suppresses deprecated bits in output, and thus permits
"testing the future". Implement it for QMP command results. Example:
when QEMU is run with -compat deprecated-output=hide, then
{"execute": "query-cpus-fast"}
yields
{"return": [{"thread-id": 9805, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
instead of
{"return": [{"arch": "x86", "thread-id": 22436, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
Note the suppression of deprecated member "arch".
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20210318155519.1224118-4-armbru@redhat.com>
2021-03-18 18:55:11 +03:00
|
|
|
FeatureStruct1 *qmp_test_features0(bool has_fs0, FeatureStruct0 *fs0,
|
|
|
|
bool has_fs1, FeatureStruct1 *fs1,
|
|
|
|
bool has_fs2, FeatureStruct2 *fs2,
|
|
|
|
bool has_fs3, FeatureStruct3 *fs3,
|
|
|
|
bool has_fs4, FeatureStruct4 *fs4,
|
|
|
|
bool has_cfs1, CondFeatureStruct1 *cfs1,
|
|
|
|
bool has_cfs2, CondFeatureStruct2 *cfs2,
|
|
|
|
bool has_cfs3, CondFeatureStruct3 *cfs3,
|
2021-08-04 11:31:02 +03:00
|
|
|
bool has_cfs4, CondFeatureStruct4 *cfs4,
|
qapi: Implement deprecated-output=hide for QMP command results
This policy suppresses deprecated bits in output, and thus permits
"testing the future". Implement it for QMP command results. Example:
when QEMU is run with -compat deprecated-output=hide, then
{"execute": "query-cpus-fast"}
yields
{"return": [{"thread-id": 9805, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
instead of
{"return": [{"arch": "x86", "thread-id": 22436, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
Note the suppression of deprecated member "arch".
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20210318155519.1224118-4-armbru@redhat.com>
2021-03-18 18:55:11 +03:00
|
|
|
Error **errp)
|
2019-06-06 18:37:58 +03:00
|
|
|
{
|
qapi: Implement deprecated-output=hide for QMP command results
This policy suppresses deprecated bits in output, and thus permits
"testing the future". Implement it for QMP command results. Example:
when QEMU is run with -compat deprecated-output=hide, then
{"execute": "query-cpus-fast"}
yields
{"return": [{"thread-id": 9805, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
instead of
{"return": [{"arch": "x86", "thread-id": 22436, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
Note the suppression of deprecated member "arch".
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20210318155519.1224118-4-armbru@redhat.com>
2021-03-18 18:55:11 +03:00
|
|
|
return g_new0(FeatureStruct1, 1);
|
2019-06-06 18:37:58 +03:00
|
|
|
}
|
|
|
|
|
2019-10-18 11:14:52 +03:00
|
|
|
void qmp_test_command_features1(Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void qmp_test_command_features3(Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void qmp_test_command_cond_features1(Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void qmp_test_command_cond_features2(Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void qmp_test_command_cond_features3(Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-03-01 11:40:28 +04:00
|
|
|
UserDefTwo *qmp_user_def_cmd2(UserDefOne *ud1a,
|
|
|
|
bool has_udb1, UserDefOne *ud1b,
|
|
|
|
Error **errp)
|
2011-07-19 23:50:45 +04:00
|
|
|
{
|
|
|
|
UserDefTwo *ret;
|
2011-08-21 07:09:37 +04:00
|
|
|
UserDefOne *ud1c = g_malloc0(sizeof(UserDefOne));
|
|
|
|
UserDefOne *ud1d = g_malloc0(sizeof(UserDefOne));
|
2011-07-19 23:50:45 +04:00
|
|
|
|
|
|
|
ud1c->string = strdup(ud1a->string);
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-27 01:34:49 +03:00
|
|
|
ud1c->integer = ud1a->integer;
|
2014-03-01 11:40:28 +04:00
|
|
|
ud1d->string = strdup(has_udb1 ? ud1b->string : "blah0");
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-27 01:34:49 +03:00
|
|
|
ud1d->integer = has_udb1 ? ud1b->integer : 0;
|
2011-07-19 23:50:45 +04:00
|
|
|
|
2015-05-04 18:05:29 +03:00
|
|
|
ret = g_new0(UserDefTwo, 1);
|
|
|
|
ret->string0 = strdup("blah1");
|
qapi: Drop tests for inline nested structs
A future patch will be using a 'name':{dictionary} entry in the
QAPI schema to specify a default value for an optional argument;
but existing use of inline nested structs conflicts with that goal.
More precisely, a definition in the QAPI schema associates a name
with a set of properties:
Example 1: { 'struct': 'Foo', 'data': { MEMBERS... } }
associates the global name 'Foo' with properties (meta-type struct)
and MEMBERS...
Example 2: 'mumble': TYPE
within MEMBERS... above associates 'mumble' with properties (type
TYPE) and (optional false) within type Foo
The syntax of example 1 is extensible; if we need another property,
we add another name/value pair to the dictionary (such as
'base':TYPE). The syntax of example 2 is not extensible, because
the right hand side can only be a type.
We have used name encoding to add a property: "'*mumble': 'int'"
associates 'mumble' with (type int) and (optional true). Nice,
but doesn't scale. So the solution is to change our existing uses
to be syntactic sugar to an extensible form:
NAME: TYPE --> NAME: { 'type': TYPE, 'optional': false }
*ONAME: TYPE --> ONAME: { 'type': TYPE, 'optional': true }
This patch fixes the testsuite to avoid inline nested types, by
breaking the nesting into explicit types; it means that the type
is now boxed instead of unboxed in C code, but makes no difference
on the wire (and if desired, a later patch could change the
generator to not do so much boxing in C). When touching code to
add new allocations, also convert existing allocations to
consistently prefer typesafe g_new0 over g_malloc0 when a type
name is involved.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-05-04 18:05:30 +03:00
|
|
|
ret->dict1 = g_new0(UserDefTwoDict, 1);
|
|
|
|
ret->dict1->string1 = strdup("blah2");
|
|
|
|
ret->dict1->dict2 = g_new0(UserDefTwoDictDict, 1);
|
|
|
|
ret->dict1->dict2->userdef = ud1c;
|
|
|
|
ret->dict1->dict2->string = strdup("blah3");
|
|
|
|
ret->dict1->dict3 = g_new0(UserDefTwoDictDict, 1);
|
|
|
|
ret->dict1->has_dict3 = true;
|
|
|
|
ret->dict1->dict3->userdef = ud1d;
|
|
|
|
ret->dict1->dict3->string = strdup("blah4");
|
2011-07-19 23:50:45 +04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-10-13 07:22:25 +03:00
|
|
|
int64_t qmp_guest_get_time(int64_t a, bool has_b, int64_t b, Error **errp)
|
2014-03-01 11:40:29 +04:00
|
|
|
{
|
|
|
|
return a + (has_b ? b : 0);
|
|
|
|
}
|
|
|
|
|
2015-09-16 14:06:24 +03:00
|
|
|
QObject *qmp_guest_sync(QObject *arg, Error **errp)
|
|
|
|
{
|
|
|
|
return arg;
|
|
|
|
}
|
|
|
|
|
2016-07-14 06:50:20 +03:00
|
|
|
void qmp_boxed_struct(UserDefZero *arg, Error **errp)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-09-17 17:31:26 +03:00
|
|
|
void qmp_boxed_union(UserDefFlatUnion *arg, Error **errp)
|
2019-09-13 23:13:41 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void qmp_boxed_empty(Empty1 *arg, Error **errp)
|
2016-07-14 06:50:20 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-09-17 17:31:30 +03:00
|
|
|
void qmp___org_qemu_x_command(__org_qemu_x_EnumList *a,
|
|
|
|
__org_qemu_x_StructList *b,
|
|
|
|
__org_qemu_x_Union *c,
|
|
|
|
__org_qemu_x_Alt *d,
|
|
|
|
Error **errp)
|
2015-05-14 15:51:01 +03:00
|
|
|
{
|
2015-11-18 11:52:52 +03:00
|
|
|
/* Also test that 'wchar-t' was munged to 'q_wchar_t' */
|
|
|
|
if (b && b->value && !b->value->has_q_wchar_t) {
|
|
|
|
b->value->q_wchar_t = 1;
|
|
|
|
}
|
2015-05-14 15:51:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-03-17 14:54:32 +03:00
|
|
|
static QObject *do_qmp_dispatch(bool allow_oob, const char *template, ...)
|
2020-03-17 14:54:30 +03:00
|
|
|
{
|
2020-03-17 14:54:32 +03:00
|
|
|
va_list ap;
|
|
|
|
QDict *req, *resp;
|
2020-03-17 14:54:30 +03:00
|
|
|
QObject *ret;
|
|
|
|
|
2020-03-17 14:54:32 +03:00
|
|
|
va_start(ap, template);
|
|
|
|
req = qdict_from_vjsonf_nofail(template, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
2020-10-05 18:58:47 +03:00
|
|
|
resp = qmp_dispatch(&qmp_commands, QOBJECT(req), allow_oob, NULL);
|
2020-03-17 14:54:31 +03:00
|
|
|
g_assert(resp);
|
2020-03-17 14:54:30 +03:00
|
|
|
ret = qdict_get(resp, "return");
|
|
|
|
g_assert(ret);
|
2020-03-17 14:54:31 +03:00
|
|
|
g_assert(qdict_size(resp) == 1);
|
2020-03-17 14:54:30 +03:00
|
|
|
|
|
|
|
qobject_ref(ret);
|
|
|
|
qobject_unref(resp);
|
2020-03-17 14:54:32 +03:00
|
|
|
qobject_unref(req);
|
2020-03-17 14:54:30 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-03-17 14:54:32 +03:00
|
|
|
static void do_qmp_dispatch_error(bool allow_oob, ErrorClass cls,
|
|
|
|
const char *template, ...)
|
2020-03-17 14:54:30 +03:00
|
|
|
{
|
2020-03-17 14:54:32 +03:00
|
|
|
va_list ap;
|
|
|
|
QDict *req, *resp;
|
2020-03-17 14:54:31 +03:00
|
|
|
QDict *error;
|
2020-03-17 14:54:30 +03:00
|
|
|
|
2020-03-17 14:54:32 +03:00
|
|
|
va_start(ap, template);
|
|
|
|
req = qdict_from_vjsonf_nofail(template, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
2020-10-05 18:58:47 +03:00
|
|
|
resp = qmp_dispatch(&qmp_commands, QOBJECT(req), allow_oob, NULL);
|
2020-03-17 14:54:31 +03:00
|
|
|
g_assert(resp);
|
|
|
|
error = qdict_get_qdict(resp, "error");
|
|
|
|
g_assert(error);
|
|
|
|
g_assert_cmpstr(qdict_get_try_str(error, "class"),
|
|
|
|
==, QapiErrorClass_str(cls));
|
|
|
|
g_assert(qdict_get_try_str(error, "desc"));
|
|
|
|
g_assert(qdict_size(error) == 2);
|
|
|
|
g_assert(qdict_size(resp) == 1);
|
2020-03-17 14:54:30 +03:00
|
|
|
|
|
|
|
qobject_unref(resp);
|
2020-03-17 14:54:32 +03:00
|
|
|
qobject_unref(req);
|
2020-03-17 14:54:30 +03:00
|
|
|
}
|
|
|
|
|
2011-07-19 23:50:45 +04:00
|
|
|
/* test commands with no input and no return value */
|
|
|
|
static void test_dispatch_cmd(void)
|
|
|
|
{
|
2020-03-17 14:54:31 +03:00
|
|
|
QDict *ret;
|
2011-07-19 23:50:45 +04:00
|
|
|
|
2020-03-17 14:54:32 +03:00
|
|
|
ret = qobject_to(QDict,
|
|
|
|
do_qmp_dispatch(false,
|
2021-03-23 12:40:21 +03:00
|
|
|
"{ 'execute': 'user-def-cmd' }"));
|
2020-03-17 14:54:31 +03:00
|
|
|
assert(ret && qdict_size(ret) == 0);
|
2020-03-17 14:54:30 +03:00
|
|
|
qobject_unref(ret);
|
2011-07-19 23:50:45 +04:00
|
|
|
}
|
|
|
|
|
2018-10-09 09:27:17 +03:00
|
|
|
static void test_dispatch_cmd_oob(void)
|
|
|
|
{
|
2020-03-17 14:54:31 +03:00
|
|
|
QDict *ret;
|
2018-10-09 09:27:17 +03:00
|
|
|
|
2020-03-17 14:54:32 +03:00
|
|
|
ret = qobject_to(QDict,
|
|
|
|
do_qmp_dispatch(true,
|
|
|
|
"{ 'exec-oob': 'test-flags-command' }"));
|
2020-03-17 14:54:31 +03:00
|
|
|
assert(ret && qdict_size(ret) == 0);
|
2020-03-17 14:54:30 +03:00
|
|
|
qobject_unref(ret);
|
2018-10-09 09:27:17 +03:00
|
|
|
}
|
|
|
|
|
2011-07-19 23:50:45 +04:00
|
|
|
/* test commands that return an error due to invalid parameters */
|
2016-08-04 13:39:38 +03:00
|
|
|
static void test_dispatch_cmd_failure(void)
|
2011-07-19 23:50:45 +04:00
|
|
|
{
|
2020-03-17 14:54:32 +03:00
|
|
|
/* missing arguments */
|
|
|
|
do_qmp_dispatch_error(false, ERROR_CLASS_GENERIC_ERROR,
|
2021-03-23 12:40:21 +03:00
|
|
|
"{ 'execute': 'user-def-cmd2' }");
|
2020-03-17 14:54:32 +03:00
|
|
|
|
|
|
|
/* extra arguments */
|
|
|
|
do_qmp_dispatch_error(false, ERROR_CLASS_GENERIC_ERROR,
|
2021-03-23 12:40:21 +03:00
|
|
|
"{ 'execute': 'user-def-cmd',"
|
2020-03-17 14:54:32 +03:00
|
|
|
" 'arguments': { 'a': 66 } }");
|
2011-07-19 23:50:45 +04:00
|
|
|
}
|
|
|
|
|
2018-08-30 18:58:10 +03:00
|
|
|
static void test_dispatch_cmd_success_response(void)
|
|
|
|
{
|
|
|
|
QDict *req = qdict_new();
|
|
|
|
QDict *resp;
|
|
|
|
|
|
|
|
qdict_put_str(req, "execute", "cmd-success-response");
|
2020-10-05 18:58:47 +03:00
|
|
|
resp = qmp_dispatch(&qmp_commands, QOBJECT(req), false, NULL);
|
2018-08-30 18:58:10 +03:00
|
|
|
g_assert_null(resp);
|
|
|
|
qobject_unref(req);
|
|
|
|
}
|
|
|
|
|
2011-07-19 23:50:45 +04:00
|
|
|
/* test commands that involve both input parameters and return values */
|
|
|
|
static void test_dispatch_cmd_io(void)
|
|
|
|
{
|
2014-03-01 11:40:27 +04:00
|
|
|
QDict *ret, *ret_dict, *ret_dict_dict, *ret_dict_dict_userdef;
|
|
|
|
QDict *ret_dict_dict2, *ret_dict_dict2_userdef;
|
2017-06-07 19:35:58 +03:00
|
|
|
QNum *ret3;
|
|
|
|
int64_t val;
|
2011-07-19 23:50:45 +04:00
|
|
|
|
2020-03-17 14:54:32 +03:00
|
|
|
ret = qobject_to(QDict, do_qmp_dispatch(false,
|
2021-03-23 12:40:21 +03:00
|
|
|
"{ 'execute': 'user-def-cmd2', 'arguments': {"
|
2020-03-17 14:54:32 +03:00
|
|
|
" 'ud1a': { 'integer': 42, 'string': 'hello' },"
|
|
|
|
" 'ud1b': { 'integer': 422, 'string': 'hello2' } } }"));
|
2014-03-01 11:40:27 +04:00
|
|
|
|
2015-05-04 18:05:29 +03:00
|
|
|
assert(!strcmp(qdict_get_str(ret, "string0"), "blah1"));
|
|
|
|
ret_dict = qdict_get_qdict(ret, "dict1");
|
|
|
|
assert(!strcmp(qdict_get_str(ret_dict, "string1"), "blah2"));
|
|
|
|
ret_dict_dict = qdict_get_qdict(ret_dict, "dict2");
|
2014-03-01 11:40:27 +04:00
|
|
|
ret_dict_dict_userdef = qdict_get_qdict(ret_dict_dict, "userdef");
|
|
|
|
assert(qdict_get_int(ret_dict_dict_userdef, "integer") == 42);
|
|
|
|
assert(!strcmp(qdict_get_str(ret_dict_dict_userdef, "string"), "hello"));
|
|
|
|
assert(!strcmp(qdict_get_str(ret_dict_dict, "string"), "blah3"));
|
2015-05-04 18:05:29 +03:00
|
|
|
ret_dict_dict2 = qdict_get_qdict(ret_dict, "dict3");
|
2014-03-01 11:40:27 +04:00
|
|
|
ret_dict_dict2_userdef = qdict_get_qdict(ret_dict_dict2, "userdef");
|
|
|
|
assert(qdict_get_int(ret_dict_dict2_userdef, "integer") == 422);
|
|
|
|
assert(!strcmp(qdict_get_str(ret_dict_dict2_userdef, "string"), "hello2"));
|
|
|
|
assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4"));
|
2018-04-19 18:01:43 +03:00
|
|
|
qobject_unref(ret);
|
2014-03-01 11:40:29 +04:00
|
|
|
|
2020-03-17 14:54:32 +03:00
|
|
|
ret3 = qobject_to(QNum, do_qmp_dispatch(false,
|
|
|
|
"{ 'execute': 'guest-get-time', 'arguments': { 'a': 66 } }"));
|
2017-06-07 19:35:58 +03:00
|
|
|
g_assert(qnum_get_try_int(ret3, &val));
|
|
|
|
g_assert_cmpint(val, ==, 66);
|
2018-04-19 18:01:43 +03:00
|
|
|
qobject_unref(ret3);
|
2011-07-19 23:50:45 +04:00
|
|
|
}
|
|
|
|
|
2021-03-18 18:55:17 +03:00
|
|
|
static void test_dispatch_cmd_deprecated(void)
|
|
|
|
{
|
|
|
|
const char *cmd = "{ 'execute': 'test-command-features1' }";
|
|
|
|
QDict *ret;
|
|
|
|
|
|
|
|
memset(&compat_policy, 0, sizeof(compat_policy));
|
|
|
|
|
|
|
|
/* accept */
|
|
|
|
ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
|
|
|
|
assert(ret && qdict_size(ret) == 0);
|
|
|
|
qobject_unref(ret);
|
|
|
|
|
|
|
|
compat_policy.has_deprecated_input = true;
|
|
|
|
compat_policy.deprecated_input = COMPAT_POLICY_INPUT_ACCEPT;
|
|
|
|
ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
|
|
|
|
assert(ret && qdict_size(ret) == 0);
|
|
|
|
qobject_unref(ret);
|
|
|
|
|
|
|
|
compat_policy.deprecated_input = COMPAT_POLICY_INPUT_REJECT;
|
|
|
|
do_qmp_dispatch_error(false, ERROR_CLASS_COMMAND_NOT_FOUND, cmd);
|
|
|
|
}
|
|
|
|
|
2021-03-18 18:55:18 +03:00
|
|
|
static void test_dispatch_cmd_arg_deprecated(void)
|
|
|
|
{
|
|
|
|
const char *cmd = "{ 'execute': 'test-features0',"
|
|
|
|
" 'arguments': { 'fs1': { 'foo': 42 } } }";
|
|
|
|
QDict *ret;
|
|
|
|
|
|
|
|
memset(&compat_policy, 0, sizeof(compat_policy));
|
|
|
|
|
|
|
|
/* accept */
|
|
|
|
ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
|
|
|
|
assert(ret && qdict_size(ret) == 1);
|
|
|
|
qobject_unref(ret);
|
|
|
|
|
|
|
|
compat_policy.has_deprecated_input = true;
|
|
|
|
compat_policy.deprecated_input = COMPAT_POLICY_INPUT_ACCEPT;
|
|
|
|
ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
|
|
|
|
assert(ret && qdict_size(ret) == 1);
|
|
|
|
qobject_unref(ret);
|
|
|
|
|
|
|
|
compat_policy.deprecated_input = COMPAT_POLICY_INPUT_REJECT;
|
|
|
|
do_qmp_dispatch_error(false, ERROR_CLASS_GENERIC_ERROR, cmd);
|
|
|
|
}
|
|
|
|
|
qapi: Implement deprecated-output=hide for QMP command results
This policy suppresses deprecated bits in output, and thus permits
"testing the future". Implement it for QMP command results. Example:
when QEMU is run with -compat deprecated-output=hide, then
{"execute": "query-cpus-fast"}
yields
{"return": [{"thread-id": 9805, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
instead of
{"return": [{"arch": "x86", "thread-id": 22436, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
Note the suppression of deprecated member "arch".
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20210318155519.1224118-4-armbru@redhat.com>
2021-03-18 18:55:11 +03:00
|
|
|
static void test_dispatch_cmd_ret_deprecated(void)
|
|
|
|
{
|
|
|
|
const char *cmd = "{ 'execute': 'test-features0' }";
|
|
|
|
QDict *ret;
|
|
|
|
|
|
|
|
memset(&compat_policy, 0, sizeof(compat_policy));
|
|
|
|
|
|
|
|
/* default accept */
|
|
|
|
ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
|
|
|
|
assert(ret && qdict_size(ret) == 1);
|
|
|
|
qobject_unref(ret);
|
|
|
|
|
|
|
|
compat_policy.has_deprecated_output = true;
|
|
|
|
compat_policy.deprecated_output = COMPAT_POLICY_OUTPUT_ACCEPT;
|
|
|
|
ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
|
|
|
|
assert(ret && qdict_size(ret) == 1);
|
|
|
|
qobject_unref(ret);
|
|
|
|
|
|
|
|
compat_policy.deprecated_output = COMPAT_POLICY_OUTPUT_HIDE;
|
|
|
|
ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
|
|
|
|
assert(ret && qdict_size(ret) == 0);
|
|
|
|
qobject_unref(ret);
|
|
|
|
}
|
|
|
|
|
2011-09-15 23:39:54 +04:00
|
|
|
/* test generated dealloc functions for generated types */
|
|
|
|
static void test_dealloc_types(void)
|
|
|
|
{
|
|
|
|
UserDefOne *ud1test, *ud1a, *ud1b;
|
|
|
|
UserDefOneList *ud1list;
|
|
|
|
|
|
|
|
ud1test = g_malloc0(sizeof(UserDefOne));
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-27 01:34:49 +03:00
|
|
|
ud1test->integer = 42;
|
2011-09-15 23:39:54 +04:00
|
|
|
ud1test->string = g_strdup("hi there 42");
|
|
|
|
|
|
|
|
qapi_free_UserDefOne(ud1test);
|
|
|
|
|
|
|
|
ud1a = g_malloc0(sizeof(UserDefOne));
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-27 01:34:49 +03:00
|
|
|
ud1a->integer = 43;
|
2011-09-15 23:39:54 +04:00
|
|
|
ud1a->string = g_strdup("hi there 43");
|
|
|
|
|
|
|
|
ud1b = g_malloc0(sizeof(UserDefOne));
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-27 01:34:49 +03:00
|
|
|
ud1b->integer = 44;
|
2011-09-15 23:39:54 +04:00
|
|
|
ud1b->string = g_strdup("hi there 44");
|
|
|
|
|
|
|
|
ud1list = g_malloc0(sizeof(UserDefOneList));
|
|
|
|
ud1list->value = ud1a;
|
|
|
|
ud1list->next = g_malloc0(sizeof(UserDefOneList));
|
|
|
|
ud1list->next->value = ud1b;
|
|
|
|
|
|
|
|
qapi_free_UserDefOneList(ud1list);
|
|
|
|
}
|
|
|
|
|
2012-07-17 18:17:05 +04:00
|
|
|
/* test generated deallocation on an object whose construction was prematurely
|
|
|
|
* terminated due to an error */
|
|
|
|
static void test_dealloc_partial(void)
|
|
|
|
{
|
|
|
|
static const char text[] = "don't leak me";
|
|
|
|
|
|
|
|
UserDefTwo *ud2 = NULL;
|
|
|
|
Error *err = NULL;
|
|
|
|
|
|
|
|
/* create partial object */
|
|
|
|
{
|
|
|
|
QDict *ud2_dict;
|
qmp-input-visitor: Favor new visit_free() function
Now that we have a polymorphic visit_free(), we no longer need
qmp_input_visitor_cleanup(); which in turn means we no longer
need to return a subtype from qmp_input_visitor_new() nor a
public upcast function.
Generated code changes to qmp-marshal.c look like:
|@@ -52,11 +52,10 @@ void qmp_marshal_add_fd(QDict *args, QOb
| {
| Error *err = NULL;
| AddfdInfo *retval;
|- QmpInputVisitor *qiv = qmp_input_visitor_new(QOBJECT(args), true);
| Visitor *v;
| q_obj_add_fd_arg arg = {0};
|
|- v = qmp_input_get_visitor(qiv);
|+ v = qmp_input_visitor_new(QOBJECT(args), true);
| visit_start_struct(v, NULL, NULL, 0, &err);
| if (err) {
| goto out;
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-8-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 19:48:38 +03:00
|
|
|
Visitor *v;
|
2012-07-17 18:17:05 +04:00
|
|
|
|
|
|
|
ud2_dict = qdict_new();
|
2017-04-28 00:58:17 +03:00
|
|
|
qdict_put_str(ud2_dict, "string0", text);
|
2012-07-17 18:17:05 +04:00
|
|
|
|
2017-03-03 15:32:39 +03:00
|
|
|
v = qobject_input_visitor_new(QOBJECT(ud2_dict));
|
qmp-input-visitor: Favor new visit_free() function
Now that we have a polymorphic visit_free(), we no longer need
qmp_input_visitor_cleanup(); which in turn means we no longer
need to return a subtype from qmp_input_visitor_new() nor a
public upcast function.
Generated code changes to qmp-marshal.c look like:
|@@ -52,11 +52,10 @@ void qmp_marshal_add_fd(QDict *args, QOb
| {
| Error *err = NULL;
| AddfdInfo *retval;
|- QmpInputVisitor *qiv = qmp_input_visitor_new(QOBJECT(args), true);
| Visitor *v;
| q_obj_add_fd_arg arg = {0};
|
|- v = qmp_input_get_visitor(qiv);
|+ v = qmp_input_visitor_new(QOBJECT(args), true);
| visit_start_struct(v, NULL, NULL, 0, &err);
| if (err) {
| goto out;
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-8-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 19:48:38 +03:00
|
|
|
visit_type_UserDefTwo(v, NULL, &ud2, &err);
|
|
|
|
visit_free(v);
|
2018-04-19 18:01:43 +03:00
|
|
|
qobject_unref(ud2_dict);
|
2012-07-17 18:17:05 +04:00
|
|
|
}
|
|
|
|
|
2016-04-29 00:45:32 +03:00
|
|
|
/* verify that visit_type_XXX() cleans up properly on error */
|
2015-11-06 09:35:31 +03:00
|
|
|
error_free_or_abort(&err);
|
2016-04-29 00:45:32 +03:00
|
|
|
assert(!ud2);
|
|
|
|
|
|
|
|
/* Manually create a partial object, leaving ud2->dict1 at NULL */
|
|
|
|
ud2 = g_new0(UserDefTwo, 1);
|
|
|
|
ud2->string0 = g_strdup(text);
|
2012-07-17 18:17:05 +04:00
|
|
|
|
|
|
|
/* tear down partial object */
|
|
|
|
qapi_free_UserDefTwo(ud2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-19 23:50:45 +04:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
g_test_init(&argc, &argv, NULL);
|
|
|
|
|
2018-03-26 18:08:49 +03:00
|
|
|
g_test_add_func("/qmp/dispatch_cmd", test_dispatch_cmd);
|
2018-10-09 09:27:17 +03:00
|
|
|
g_test_add_func("/qmp/dispatch_cmd_oob", test_dispatch_cmd_oob);
|
2018-03-26 18:08:49 +03:00
|
|
|
g_test_add_func("/qmp/dispatch_cmd_failure", test_dispatch_cmd_failure);
|
|
|
|
g_test_add_func("/qmp/dispatch_cmd_io", test_dispatch_cmd_io);
|
2018-08-30 18:58:10 +03:00
|
|
|
g_test_add_func("/qmp/dispatch_cmd_success_response",
|
|
|
|
test_dispatch_cmd_success_response);
|
2021-03-18 18:55:17 +03:00
|
|
|
g_test_add_func("/qmp/dispatch_cmd_deprecated",
|
|
|
|
test_dispatch_cmd_deprecated);
|
2021-03-18 18:55:18 +03:00
|
|
|
g_test_add_func("/qmp/dispatch_cmd_arg_deprecated",
|
|
|
|
test_dispatch_cmd_arg_deprecated);
|
qapi: Implement deprecated-output=hide for QMP command results
This policy suppresses deprecated bits in output, and thus permits
"testing the future". Implement it for QMP command results. Example:
when QEMU is run with -compat deprecated-output=hide, then
{"execute": "query-cpus-fast"}
yields
{"return": [{"thread-id": 9805, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
instead of
{"return": [{"arch": "x86", "thread-id": 22436, "props": {"core-id": 0, "thread-id": 0, "socket-id": 0}, "qom-path": "/machine/unattached/device[0]", "cpu-index": 0, "target": "x86_64"}]}
Note the suppression of deprecated member "arch".
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20210318155519.1224118-4-armbru@redhat.com>
2021-03-18 18:55:11 +03:00
|
|
|
g_test_add_func("/qmp/dispatch_cmd_ret_deprecated",
|
|
|
|
test_dispatch_cmd_ret_deprecated);
|
2018-03-26 18:08:49 +03:00
|
|
|
g_test_add_func("/qmp/dealloc_types", test_dealloc_types);
|
|
|
|
g_test_add_func("/qmp/dealloc_partial", test_dealloc_partial);
|
2011-07-19 23:50:45 +04:00
|
|
|
|
2017-03-03 15:32:25 +03:00
|
|
|
test_qmp_init_marshal(&qmp_commands);
|
2011-07-19 23:50:45 +04:00
|
|
|
g_test_run();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|