2011-07-19 19:50:42 +00:00
|
|
|
#
|
|
|
|
# QAPI command marshaller generator
|
|
|
|
#
|
|
|
|
# Copyright IBM, Corp. 2011
|
qapi: Unify type bypass and add tests
For a few QMP commands, we are forced to pass an arbitrary type
without tracking it properly in QAPI. Among the existing clients,
this unnamed type was spelled 'dict', 'visitor', and '**'; this
patch standardizes on '**', matching the documentation changes
earlier in the series.
Meanwhile, for the 'gen' key, we have been ignoring the value,
although the schema consistently used "'no'" ('success-response'
was hard-coded to checking for 'no'). But now that we can support
a literal "false" in the schema, we might as well use that rather
than ignoring the value or special-casing a random string. Note
that these are one-way switches (use of 'gen':true is not the same
as omitting 'gen'). Also, the use of '**' requires 'gen':false,
but the use of 'gen':false does not mandate the use of '**'.
There is no difference to the generated code. Add some tests on
what we'd like to guarantee, although it will take later patches
to clean up test results and actually enforce the use of a bool
parameter.
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 15:05:19 +00:00
|
|
|
# Copyright (C) 2014-2015 Red Hat, Inc.
|
2011-07-19 19:50:42 +00:00
|
|
|
#
|
|
|
|
# Authors:
|
|
|
|
# Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
# Michael Roth <mdroth@linux.vnet.ibm.com>
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
# Markus Armbruster <armbru@redhat.com>
|
2011-07-19 19:50:42 +00:00
|
|
|
#
|
2014-03-01 07:40:34 +00:00
|
|
|
# This work is licensed under the terms of the GNU GPL, version 2.
|
|
|
|
# See the COPYING file in the top-level directory.
|
2011-07-19 19:50:42 +00:00
|
|
|
|
|
|
|
from ordereddict import OrderedDict
|
|
|
|
from qapi import *
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
import re
|
2011-07-19 19:50:42 +00:00
|
|
|
|
|
|
|
def generate_command_decl(name, args, ret_type):
|
|
|
|
arglist=""
|
2015-05-04 15:05:33 +00:00
|
|
|
for argname, argtype, optional in parse_args(args):
|
2014-06-10 11:25:52 +00:00
|
|
|
argtype = c_type(argtype, is_param=True)
|
2011-07-19 19:50:42 +00:00
|
|
|
if optional:
|
2015-05-14 12:50:48 +00:00
|
|
|
arglist += "bool has_%s, " % c_name(argname)
|
|
|
|
arglist += "%s %s, " % (argtype, c_name(argname))
|
2011-07-19 19:50:42 +00:00
|
|
|
return mcgen('''
|
|
|
|
%(ret_type)s qmp_%(name)s(%(args)sError **errp);
|
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
ret_type=c_type(ret_type), name=c_name(name),
|
|
|
|
args=arglist).strip()
|
2011-07-19 19:50:42 +00:00
|
|
|
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
def gen_err_check(errvar):
|
|
|
|
if errvar:
|
|
|
|
return mcgen('''
|
|
|
|
if (local_err) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
''')
|
|
|
|
return ''
|
|
|
|
|
2011-07-19 19:50:42 +00:00
|
|
|
def gen_sync_call(name, args, ret_type, indent=0):
|
|
|
|
ret = ""
|
|
|
|
arglist=""
|
|
|
|
retval=""
|
|
|
|
if ret_type:
|
|
|
|
retval = "retval = "
|
2015-05-04 15:05:33 +00:00
|
|
|
for argname, argtype, optional in parse_args(args):
|
2011-07-19 19:50:42 +00:00
|
|
|
if optional:
|
2015-05-14 12:50:48 +00:00
|
|
|
arglist += "has_%s, " % c_name(argname)
|
|
|
|
arglist += "%s, " % (c_name(argname))
|
2011-07-19 19:50:42 +00:00
|
|
|
push_indent(indent)
|
|
|
|
ret = mcgen('''
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
%(retval)sqmp_%(name)s(%(args)s&local_err);
|
2011-07-19 19:50:42 +00:00
|
|
|
|
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
name=c_name(name), args=arglist, retval=retval).rstrip()
|
2011-07-19 19:50:42 +00:00
|
|
|
if ret_type:
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
ret += "\n" + gen_err_check('local_err')
|
2015-06-24 17:27:32 +00:00
|
|
|
ret += "\n" + mcgen('''
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
%(marshal_output_call)s
|
2011-07-19 19:50:42 +00:00
|
|
|
''',
|
|
|
|
marshal_output_call=gen_marshal_output_call(name, ret_type)).rstrip()
|
|
|
|
pop_indent(indent)
|
|
|
|
return ret.rstrip()
|
|
|
|
|
|
|
|
|
|
|
|
def gen_marshal_output_call(name, ret_type):
|
|
|
|
if not ret_type:
|
|
|
|
return ""
|
2015-05-14 12:50:48 +00:00
|
|
|
return "qmp_marshal_output_%s(retval, ret, &local_err);" % c_name(name)
|
2011-07-19 19:50:42 +00:00
|
|
|
|
2014-05-07 07:53:44 +00:00
|
|
|
def gen_visitor_input_containers_decl(args, obj):
|
2011-07-19 19:50:42 +00:00
|
|
|
ret = ""
|
|
|
|
|
|
|
|
push_indent()
|
|
|
|
if len(args) > 0:
|
|
|
|
ret += mcgen('''
|
2014-05-07 07:53:44 +00:00
|
|
|
QmpInputVisitor *mi = qmp_input_visitor_new_strict(%(obj)s);
|
2011-07-19 19:50:42 +00:00
|
|
|
QapiDeallocVisitor *md;
|
|
|
|
Visitor *v;
|
2014-05-07 07:53:44 +00:00
|
|
|
''',
|
|
|
|
obj=obj)
|
2011-07-19 19:50:42 +00:00
|
|
|
pop_indent()
|
|
|
|
|
|
|
|
return ret.rstrip()
|
|
|
|
|
|
|
|
def gen_visitor_input_vars_decl(args):
|
|
|
|
ret = ""
|
|
|
|
push_indent()
|
2015-05-04 15:05:33 +00:00
|
|
|
for argname, argtype, optional in parse_args(args):
|
2011-07-19 19:50:42 +00:00
|
|
|
if optional:
|
|
|
|
ret += mcgen('''
|
|
|
|
bool has_%(argname)s = false;
|
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
argname=c_name(argname))
|
2014-06-10 11:25:53 +00:00
|
|
|
if is_c_ptr(argtype):
|
2011-07-19 19:50:42 +00:00
|
|
|
ret += mcgen('''
|
|
|
|
%(argtype)s %(argname)s = NULL;
|
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
argname=c_name(argname), argtype=c_type(argtype))
|
2011-07-19 19:50:42 +00:00
|
|
|
else:
|
|
|
|
ret += mcgen('''
|
qapi: zero-initialize all QMP command parameters
In general QMP command parameter values are specified by consumers of the
QMP/HMP interface, but in the case of optional parameters these values may
be left uninitialized.
It is considered a bug for code to make use of optional parameters that have
not been flagged as being present by the marshalling code (via corresponding
has_<parameter> parameter), however our marshalling code will still pass
these uninitialized values on to the corresponding QMP function (to then
be ignored). Some compilers (clang in particular) consider this unsafe
however, and generate warnings as a result. As reported by Peter Maydell:
This is something clang's -fsanitize=undefined spotted. The
code generated by qapi-commands.py in qmp-marshal.c for
qmp_marshal_* functions where there are some optional
arguments looks like this:
bool has_force = false;
bool force;
mi = qmp_input_visitor_new_strict(QOBJECT(args));
v = qmp_input_get_visitor(mi);
visit_type_str(v, &device, "device", errp);
visit_start_optional(v, &has_force, "force", errp);
if (has_force) {
visit_type_bool(v, &force, "force", errp);
}
visit_end_optional(v, errp);
qmp_input_visitor_cleanup(mi);
if (error_is_set(errp)) {
goto out;
}
qmp_eject(device, has_force, force, errp);
In the case where has_force is false, we never initialize
force, but then we use it by passing it to qmp_eject.
I imagine we don't then actually use the value, but clang
complains in particular for 'bool' variables because the value
that ends up being loaded from memory for 'force' is not either
0 or 1 (being uninitialized stack contents).
Fix this by initializing all QMP command parameters to {0} in the
marshalling code prior to passing them on to the QMP functions.
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
Reported-by: Peter Maydell <peter.maydell@linaro.org>
Tested-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-20 17:20:39 +00:00
|
|
|
%(argtype)s %(argname)s = {0};
|
2011-07-19 19:50:42 +00:00
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
argname=c_name(argname), argtype=c_type(argtype))
|
2011-07-19 19:50:42 +00:00
|
|
|
|
|
|
|
pop_indent()
|
|
|
|
return ret.rstrip()
|
|
|
|
|
2014-05-07 07:53:44 +00:00
|
|
|
def gen_visitor_input_block(args, dealloc=False):
|
2011-07-19 19:50:42 +00:00
|
|
|
ret = ""
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
errparg = '&local_err'
|
|
|
|
errarg = 'local_err'
|
qapi: qapi-commands: fix possible leaks on visitor dealloc
In qmp-marshal.c the dealloc visitor calls use the same errp
pointer of the input visitor calls. This means that if any of
the input visitor calls fails, then the dealloc visitor will
return early, before freeing the object's memory.
Here's an example, consider this code:
int qmp_marshal_input_block_passwd(Monitor *mon, const QDict *qdict, QObject **ret)
{
[...]
char * device = NULL;
char * password = NULL;
mi = qmp_input_visitor_new_strict(QOBJECT(args));
v = qmp_input_get_visitor(mi);
visit_type_str(v, &device, "device", errp);
visit_type_str(v, &password, "password", errp);
qmp_input_visitor_cleanup(mi);
if (error_is_set(errp)) {
goto out;
}
qmp_block_passwd(device, password, errp);
out:
md = qapi_dealloc_visitor_new();
v = qapi_dealloc_get_visitor(md);
visit_type_str(v, &device, "device", errp);
visit_type_str(v, &password, "password", errp);
qapi_dealloc_visitor_cleanup(md);
[...]
return 0;
}
Consider errp != NULL when the out label is reached, we're going
to leak device and password.
This patch fixes this by always passing errp=NULL for dealloc
visitors, meaning that we always try to free them regardless of
any previous failure. The above example would then be:
out:
md = qapi_dealloc_visitor_new();
v = qapi_dealloc_get_visitor(md);
visit_type_str(v, &device, "device", NULL);
visit_type_str(v, &password, "password", NULL);
qapi_dealloc_visitor_cleanup(md);
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
Reviewed-by: Laszlo Ersek <lersek@redhat.com>
Reviewed-by: Michael Roth <mdroth@linux.vnet.ibm.com>
2013-07-11 18:26:56 +00:00
|
|
|
|
2011-07-19 19:50:42 +00:00
|
|
|
if len(args) == 0:
|
|
|
|
return ret
|
|
|
|
|
|
|
|
push_indent()
|
|
|
|
|
|
|
|
if dealloc:
|
qapi: qapi-commands: fix possible leaks on visitor dealloc
In qmp-marshal.c the dealloc visitor calls use the same errp
pointer of the input visitor calls. This means that if any of
the input visitor calls fails, then the dealloc visitor will
return early, before freeing the object's memory.
Here's an example, consider this code:
int qmp_marshal_input_block_passwd(Monitor *mon, const QDict *qdict, QObject **ret)
{
[...]
char * device = NULL;
char * password = NULL;
mi = qmp_input_visitor_new_strict(QOBJECT(args));
v = qmp_input_get_visitor(mi);
visit_type_str(v, &device, "device", errp);
visit_type_str(v, &password, "password", errp);
qmp_input_visitor_cleanup(mi);
if (error_is_set(errp)) {
goto out;
}
qmp_block_passwd(device, password, errp);
out:
md = qapi_dealloc_visitor_new();
v = qapi_dealloc_get_visitor(md);
visit_type_str(v, &device, "device", errp);
visit_type_str(v, &password, "password", errp);
qapi_dealloc_visitor_cleanup(md);
[...]
return 0;
}
Consider errp != NULL when the out label is reached, we're going
to leak device and password.
This patch fixes this by always passing errp=NULL for dealloc
visitors, meaning that we always try to free them regardless of
any previous failure. The above example would then be:
out:
md = qapi_dealloc_visitor_new();
v = qapi_dealloc_get_visitor(md);
visit_type_str(v, &device, "device", NULL);
visit_type_str(v, &password, "password", NULL);
qapi_dealloc_visitor_cleanup(md);
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
Reviewed-by: Laszlo Ersek <lersek@redhat.com>
Reviewed-by: Michael Roth <mdroth@linux.vnet.ibm.com>
2013-07-11 18:26:56 +00:00
|
|
|
errparg = 'NULL'
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
errarg = None;
|
2011-07-19 19:50:42 +00:00
|
|
|
ret += mcgen('''
|
2014-05-07 07:53:44 +00:00
|
|
|
qmp_input_visitor_cleanup(mi);
|
2011-07-19 19:50:42 +00:00
|
|
|
md = qapi_dealloc_visitor_new();
|
|
|
|
v = qapi_dealloc_get_visitor(md);
|
|
|
|
''')
|
|
|
|
else:
|
|
|
|
ret += mcgen('''
|
|
|
|
v = qmp_input_get_visitor(mi);
|
2014-05-07 07:53:44 +00:00
|
|
|
''')
|
2011-07-19 19:50:42 +00:00
|
|
|
|
2015-05-04 15:05:33 +00:00
|
|
|
for argname, argtype, optional in parse_args(args):
|
2011-07-19 19:50:42 +00:00
|
|
|
if optional:
|
|
|
|
ret += mcgen('''
|
2014-05-07 07:53:46 +00:00
|
|
|
visit_optional(v, &has_%(c_name)s, "%(name)s", %(errp)s);
|
2011-07-19 19:50:42 +00:00
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
c_name=c_name(argname), name=argname, errp=errparg)
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
ret += gen_err_check(errarg)
|
|
|
|
ret += mcgen('''
|
|
|
|
if (has_%(c_name)s) {
|
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
c_name=c_name(argname))
|
2011-07-19 19:50:42 +00:00
|
|
|
push_indent()
|
|
|
|
ret += mcgen('''
|
2015-05-14 12:51:01 +00:00
|
|
|
visit_type_%(visitor)s(v, &%(c_name)s, "%(name)s", %(errp)s);
|
2011-07-19 19:50:42 +00:00
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
c_name=c_name(argname), name=argname, argtype=argtype,
|
2015-05-14 12:51:01 +00:00
|
|
|
visitor=type_name(argtype), errp=errparg)
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
ret += gen_err_check(errarg)
|
2011-07-19 19:50:42 +00:00
|
|
|
if optional:
|
|
|
|
pop_indent()
|
|
|
|
ret += mcgen('''
|
|
|
|
}
|
2014-05-07 07:53:46 +00:00
|
|
|
''')
|
2011-07-19 19:50:42 +00:00
|
|
|
|
|
|
|
if dealloc:
|
|
|
|
ret += mcgen('''
|
|
|
|
qapi_dealloc_visitor_cleanup(md);
|
|
|
|
''')
|
|
|
|
pop_indent()
|
|
|
|
return ret.rstrip()
|
|
|
|
|
2011-09-02 17:34:46 +00:00
|
|
|
def gen_marshal_output(name, args, ret_type, middle_mode):
|
2011-07-19 19:50:42 +00:00
|
|
|
if not ret_type:
|
|
|
|
return ""
|
2011-09-02 17:34:46 +00:00
|
|
|
|
2011-07-19 19:50:42 +00:00
|
|
|
ret = mcgen('''
|
|
|
|
static void qmp_marshal_output_%(c_name)s(%(c_ret_type)s ret_in, QObject **ret_out, Error **errp)
|
|
|
|
{
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
Error *local_err = NULL;
|
2011-07-19 19:50:42 +00:00
|
|
|
QmpOutputVisitor *mo = qmp_output_visitor_new();
|
2014-05-07 07:53:44 +00:00
|
|
|
QapiDeallocVisitor *md;
|
2011-07-19 19:50:42 +00:00
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
v = qmp_output_get_visitor(mo);
|
2015-05-14 12:51:01 +00:00
|
|
|
visit_type_%(visitor)s(v, &ret_in, "unused", &local_err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
if (local_err) {
|
|
|
|
goto out;
|
2011-07-19 19:50:42 +00:00
|
|
|
}
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
*ret_out = qmp_output_get_qobject(mo);
|
|
|
|
|
|
|
|
out:
|
|
|
|
error_propagate(errp, local_err);
|
2011-07-19 19:50:42 +00:00
|
|
|
qmp_output_visitor_cleanup(mo);
|
2014-05-07 07:53:44 +00:00
|
|
|
md = qapi_dealloc_visitor_new();
|
2011-07-19 19:50:42 +00:00
|
|
|
v = qapi_dealloc_get_visitor(md);
|
2015-05-14 12:51:01 +00:00
|
|
|
visit_type_%(visitor)s(v, &ret_in, "unused", NULL);
|
2011-07-19 19:50:42 +00:00
|
|
|
qapi_dealloc_visitor_cleanup(md);
|
|
|
|
}
|
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
c_ret_type=c_type(ret_type), c_name=c_name(name),
|
2015-05-14 12:51:01 +00:00
|
|
|
visitor=type_name(ret_type))
|
2011-07-19 19:50:42 +00:00
|
|
|
|
|
|
|
return ret
|
|
|
|
|
2011-09-02 17:34:46 +00:00
|
|
|
def gen_marshal_input_decl(name, args, ret_type, middle_mode):
|
qmp: Wean off qerror_report()
The traditional QMP command handler interface
int qmp_FOO(Monitor *mon, const QDict *params, QObject **ret_data);
doesn't provide for returning an Error object. Instead, the handler
is expected to stash it in the monitor with qerror_report().
When we rebased QMP on top of QAPI, we didn't change this interface.
Instead, commit 776574d introduced "middle mode" as a temporary aid
for converting existing QMP commands to QAPI one by one. More than
three years later, we're still using it.
Middle mode has two effects:
* Instead of the native input marshallers
static void qmp_marshal_input_FOO(QDict *, QObject **, Error **)
it generates input marshallers conforming to the traditional QMP
command handler interface.
* It suppresses generation of code to register them with
qmp_register_command()
This permits giving them internal linkage.
As long as we need qmp-commands.hx, we can't use the registry behind
qmp_register_command(), so the latter has to stay for now.
The former has to go to get rid of qerror_report(). Changing all QMP
commands to fit the QAPI mold in one go was impractical back when we
started, but by now there are just a few stragglers left:
do_qmp_capabilities(), qmp_qom_set(), qmp_qom_get(), qmp_object_add(),
qmp_netdev_add(), do_device_add().
Switch middle mode to generate native input marshallers, and adapt the
stragglers. Simplifies both the monitor code and the stragglers.
Rename do_qmp_capabilities() to qmp_capabilities(), and
do_device_add() to qmp_device_add, because that's how QMP command
handlers are named today.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-03-13 16:25:50 +00:00
|
|
|
ret = 'void qmp_marshal_input_%s(QDict *args, QObject **ret, Error **errp)' % c_name(name)
|
|
|
|
if not middle_mode:
|
|
|
|
ret = "static " + ret
|
|
|
|
return ret
|
2011-09-02 17:34:46 +00:00
|
|
|
|
|
|
|
def gen_marshal_input(name, args, ret_type, middle_mode):
|
|
|
|
hdr = gen_marshal_input_decl(name, args, ret_type, middle_mode)
|
|
|
|
|
2011-07-19 19:50:42 +00:00
|
|
|
ret = mcgen('''
|
2011-09-02 17:34:46 +00:00
|
|
|
%(header)s
|
2011-07-19 19:50:42 +00:00
|
|
|
{
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
Error *local_err = NULL;
|
2011-07-19 19:50:42 +00:00
|
|
|
''',
|
2011-09-02 17:34:46 +00:00
|
|
|
header=hdr)
|
|
|
|
|
2011-07-19 19:50:42 +00:00
|
|
|
if ret_type:
|
2014-06-10 11:25:53 +00:00
|
|
|
if is_c_ptr(ret_type):
|
2011-07-19 19:50:42 +00:00
|
|
|
retval = " %s retval = NULL;" % c_type(ret_type)
|
|
|
|
else:
|
|
|
|
retval = " %s retval;" % c_type(ret_type)
|
|
|
|
ret += mcgen('''
|
|
|
|
%(retval)s
|
|
|
|
''',
|
|
|
|
retval=retval)
|
|
|
|
|
|
|
|
if len(args) > 0:
|
|
|
|
ret += mcgen('''
|
|
|
|
%(visitor_input_containers_decl)s
|
|
|
|
%(visitor_input_vars_decl)s
|
|
|
|
|
|
|
|
%(visitor_input_block)s
|
|
|
|
|
|
|
|
''',
|
2014-05-07 07:53:44 +00:00
|
|
|
visitor_input_containers_decl=gen_visitor_input_containers_decl(args, "QOBJECT(args)"),
|
2011-07-19 19:50:42 +00:00
|
|
|
visitor_input_vars_decl=gen_visitor_input_vars_decl(args),
|
2014-05-07 07:53:44 +00:00
|
|
|
visitor_input_block=gen_visitor_input_block(args))
|
2011-09-02 17:34:46 +00:00
|
|
|
else:
|
|
|
|
ret += mcgen('''
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
|
2011-09-02 17:34:46 +00:00
|
|
|
(void)args;
|
|
|
|
''')
|
2011-07-19 19:50:42 +00:00
|
|
|
|
|
|
|
ret += mcgen('''
|
|
|
|
%(sync_call)s
|
|
|
|
''',
|
|
|
|
sync_call=gen_sync_call(name, args, ret_type, indent=4))
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 07:53:54 +00:00
|
|
|
if re.search('^ *goto out\\;', ret, re.MULTILINE):
|
|
|
|
ret += mcgen('''
|
2011-07-19 19:50:42 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
''')
|
|
|
|
ret += mcgen('''
|
qmp: Wean off qerror_report()
The traditional QMP command handler interface
int qmp_FOO(Monitor *mon, const QDict *params, QObject **ret_data);
doesn't provide for returning an Error object. Instead, the handler
is expected to stash it in the monitor with qerror_report().
When we rebased QMP on top of QAPI, we didn't change this interface.
Instead, commit 776574d introduced "middle mode" as a temporary aid
for converting existing QMP commands to QAPI one by one. More than
three years later, we're still using it.
Middle mode has two effects:
* Instead of the native input marshallers
static void qmp_marshal_input_FOO(QDict *, QObject **, Error **)
it generates input marshallers conforming to the traditional QMP
command handler interface.
* It suppresses generation of code to register them with
qmp_register_command()
This permits giving them internal linkage.
As long as we need qmp-commands.hx, we can't use the registry behind
qmp_register_command(), so the latter has to stay for now.
The former has to go to get rid of qerror_report(). Changing all QMP
commands to fit the QAPI mold in one go was impractical back when we
started, but by now there are just a few stragglers left:
do_qmp_capabilities(), qmp_qom_set(), qmp_qom_get(), qmp_object_add(),
qmp_netdev_add(), do_device_add().
Switch middle mode to generate native input marshallers, and adapt the
stragglers. Simplifies both the monitor code and the stragglers.
Rename do_qmp_capabilities() to qmp_capabilities(), and
do_device_add() to qmp_device_add, because that's how QMP command
handlers are named today.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-03-13 16:25:50 +00:00
|
|
|
error_propagate(errp, local_err);
|
2011-07-19 19:50:42 +00:00
|
|
|
%(visitor_input_block_cleanup)s
|
qmp: Wean off qerror_report()
The traditional QMP command handler interface
int qmp_FOO(Monitor *mon, const QDict *params, QObject **ret_data);
doesn't provide for returning an Error object. Instead, the handler
is expected to stash it in the monitor with qerror_report().
When we rebased QMP on top of QAPI, we didn't change this interface.
Instead, commit 776574d introduced "middle mode" as a temporary aid
for converting existing QMP commands to QAPI one by one. More than
three years later, we're still using it.
Middle mode has two effects:
* Instead of the native input marshallers
static void qmp_marshal_input_FOO(QDict *, QObject **, Error **)
it generates input marshallers conforming to the traditional QMP
command handler interface.
* It suppresses generation of code to register them with
qmp_register_command()
This permits giving them internal linkage.
As long as we need qmp-commands.hx, we can't use the registry behind
qmp_register_command(), so the latter has to stay for now.
The former has to go to get rid of qerror_report(). Changing all QMP
commands to fit the QAPI mold in one go was impractical back when we
started, but by now there are just a few stragglers left:
do_qmp_capabilities(), qmp_qom_set(), qmp_qom_get(), qmp_object_add(),
qmp_netdev_add(), do_device_add().
Switch middle mode to generate native input marshallers, and adapt the
stragglers. Simplifies both the monitor code and the stragglers.
Rename do_qmp_capabilities() to qmp_capabilities(), and
do_device_add() to qmp_device_add, because that's how QMP command
handlers are named today.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-03-13 16:25:50 +00:00
|
|
|
}
|
2011-09-02 17:34:46 +00:00
|
|
|
''',
|
2014-05-07 07:53:44 +00:00
|
|
|
visitor_input_block_cleanup=gen_visitor_input_block(args,
|
2011-09-02 17:34:46 +00:00
|
|
|
dealloc=True))
|
2011-07-19 19:50:42 +00:00
|
|
|
return ret
|
|
|
|
|
|
|
|
def gen_registry(commands):
|
|
|
|
registry=""
|
|
|
|
push_indent()
|
|
|
|
for cmd in commands:
|
2012-05-08 17:24:44 +00:00
|
|
|
options = 'QCO_NO_OPTIONS'
|
qapi: Unify type bypass and add tests
For a few QMP commands, we are forced to pass an arbitrary type
without tracking it properly in QAPI. Among the existing clients,
this unnamed type was spelled 'dict', 'visitor', and '**'; this
patch standardizes on '**', matching the documentation changes
earlier in the series.
Meanwhile, for the 'gen' key, we have been ignoring the value,
although the schema consistently used "'no'" ('success-response'
was hard-coded to checking for 'no'). But now that we can support
a literal "false" in the schema, we might as well use that rather
than ignoring the value or special-casing a random string. Note
that these are one-way switches (use of 'gen':true is not the same
as omitting 'gen'). Also, the use of '**' requires 'gen':false,
but the use of 'gen':false does not mandate the use of '**'.
There is no difference to the generated code. Add some tests on
what we'd like to guarantee, although it will take later patches
to clean up test results and actually enforce the use of a bool
parameter.
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 15:05:19 +00:00
|
|
|
if not cmd.get('success-response', True):
|
2012-05-08 17:24:44 +00:00
|
|
|
options = 'QCO_NO_SUCCESS_RESP'
|
|
|
|
|
2011-07-19 19:50:42 +00:00
|
|
|
registry += mcgen('''
|
2012-05-08 17:24:44 +00:00
|
|
|
qmp_register_command("%(name)s", qmp_marshal_input_%(c_name)s, %(opts)s);
|
2011-07-19 19:50:42 +00:00
|
|
|
''',
|
2015-05-14 12:50:48 +00:00
|
|
|
name=cmd['command'], c_name=c_name(cmd['command']),
|
2012-05-08 17:24:44 +00:00
|
|
|
opts=options)
|
2011-07-19 19:50:42 +00:00
|
|
|
pop_indent()
|
|
|
|
ret = mcgen('''
|
|
|
|
static void qmp_init_marshal(void)
|
|
|
|
{
|
|
|
|
%(registry)s
|
|
|
|
}
|
|
|
|
|
|
|
|
qapi_init(qmp_init_marshal);
|
|
|
|
''',
|
|
|
|
registry=registry.rstrip())
|
|
|
|
return ret
|
|
|
|
|
2011-09-02 17:34:46 +00:00
|
|
|
middle_mode = False
|
2011-07-19 19:50:42 +00:00
|
|
|
|
2015-04-02 11:12:21 +00:00
|
|
|
(input_file, output_dir, do_c, do_h, prefix, opts) = \
|
|
|
|
parse_command_line("m", ["middle"])
|
2011-12-27 14:02:16 +00:00
|
|
|
|
2011-07-19 19:50:42 +00:00
|
|
|
for o, a in opts:
|
2015-04-02 11:12:21 +00:00
|
|
|
if o in ("-m", "--middle"):
|
2011-09-02 17:34:46 +00:00
|
|
|
middle_mode = True
|
2011-07-19 19:50:42 +00:00
|
|
|
|
2014-05-02 13:52:35 +00:00
|
|
|
exprs = parse_schema(input_file)
|
2011-07-19 19:50:42 +00:00
|
|
|
commands = filter(lambda expr: expr.has_key('command'), exprs)
|
2011-12-12 20:29:33 +00:00
|
|
|
commands = filter(lambda expr: not expr.has_key('gen'), commands)
|
2011-07-19 19:50:42 +00:00
|
|
|
|
2015-04-02 12:46:39 +00:00
|
|
|
c_comment = '''
|
|
|
|
/*
|
|
|
|
* schema-defined QMP->QAPI command dispatch
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2011
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
'''
|
|
|
|
h_comment = '''
|
|
|
|
/*
|
|
|
|
* schema-defined QAPI function prototypes
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2011
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
'''
|
|
|
|
|
|
|
|
(fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
|
|
|
|
'qmp-marshal.c', 'qmp-commands.h',
|
|
|
|
c_comment, h_comment)
|
|
|
|
|
2015-04-02 12:52:55 +00:00
|
|
|
fdef.write(mcgen('''
|
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "qemu/module.h"
|
|
|
|
#include "qapi/qmp/types.h"
|
|
|
|
#include "qapi/qmp/dispatch.h"
|
|
|
|
#include "qapi/visitor.h"
|
|
|
|
#include "qapi/qmp-output-visitor.h"
|
|
|
|
#include "qapi/qmp-input-visitor.h"
|
|
|
|
#include "qapi/dealloc-visitor.h"
|
|
|
|
#include "%(prefix)sqapi-types.h"
|
|
|
|
#include "%(prefix)sqapi-visit.h"
|
|
|
|
#include "%(prefix)sqmp-commands.h"
|
|
|
|
|
|
|
|
''',
|
|
|
|
prefix=prefix))
|
|
|
|
|
|
|
|
fdecl.write(mcgen('''
|
|
|
|
#include "%(prefix)sqapi-types.h"
|
|
|
|
#include "qapi/qmp/qdict.h"
|
|
|
|
#include "qapi/error.h"
|
|
|
|
|
|
|
|
''',
|
|
|
|
prefix=prefix))
|
2015-04-02 09:41:22 +00:00
|
|
|
|
|
|
|
for cmd in commands:
|
|
|
|
arglist = []
|
|
|
|
ret_type = None
|
|
|
|
if cmd.has_key('data'):
|
|
|
|
arglist = cmd['data']
|
|
|
|
if cmd.has_key('returns'):
|
|
|
|
ret_type = cmd['returns']
|
|
|
|
ret = generate_command_decl(cmd['command'], arglist, ret_type) + "\n"
|
2011-07-19 19:50:42 +00:00
|
|
|
fdecl.write(ret)
|
2015-04-02 09:41:22 +00:00
|
|
|
if ret_type:
|
|
|
|
ret = gen_marshal_output(cmd['command'], arglist, ret_type, middle_mode) + "\n"
|
2011-07-19 19:50:42 +00:00
|
|
|
fdef.write(ret)
|
|
|
|
|
2015-04-02 09:41:22 +00:00
|
|
|
if middle_mode:
|
|
|
|
fdecl.write('%s;\n' % gen_marshal_input_decl(cmd['command'], arglist, ret_type, middle_mode))
|
2011-09-02 17:34:46 +00:00
|
|
|
|
2015-04-02 09:41:22 +00:00
|
|
|
ret = gen_marshal_input(cmd['command'], arglist, ret_type, middle_mode) + "\n"
|
|
|
|
fdef.write(ret)
|
|
|
|
|
|
|
|
if not middle_mode:
|
|
|
|
ret = gen_registry(commands)
|
|
|
|
fdef.write(ret)
|
2011-07-19 19:50:42 +00:00
|
|
|
|
2015-04-02 12:46:39 +00:00
|
|
|
close_output(fdef, fdecl)
|