scripts/qapi/commands.py

   1 """
   2 QAPI command marshaller generator
   3
   4 Copyright IBM, Corp. 2011
   5 Copyright (C) 2014-2018 Red Hat, Inc.
   6
   7 Authors:
   8  Anthony Liguori <aliguori@us.ibm.com>
   9  Michael Roth <mdroth@linux.vnet.ibm.com>
  10  Markus Armbruster <armbru@redhat.com>
  11
  12 This work is licensed under the terms of the GNU GPL, version 2.
  13 See the COPYING file in the top-level directory.
  14 """
  15
  16 from typing import (
  17     Dict,
  18     List,
  19     Optional,
  20     Sequence,
  21     Set,
  22 )
  23
  24 from .common import c_name, mcgen
  25 from .gen import (
  26     QAPIGenC,
  27     QAPISchemaModularCVisitor,
  28     build_params,
  29     ifcontext,
  30 )
  31 from .schema import (
  32     QAPISchema,
  33     QAPISchemaFeature,
  34     QAPISchemaObjectType,
  35     QAPISchemaType,
  36 )
  37 from .source import QAPISourceInfo
  38
  39
  40 def gen_command_decl(name: str,
  41                      arg_type: Optional[QAPISchemaObjectType],
  42                      boxed: bool,
  43                      ret_type: Optional[QAPISchemaType]) -> str:
  44     return mcgen('''
  45 %(c_type)s qmp_%(c_name)s(%(params)s);
  46 ''',
  47                  c_type=(ret_type and ret_type.c_type()) or 'void',
  48                  c_name=c_name(name),
  49                  params=build_params(arg_type, boxed, 'Error **errp'))
  50
  51
  52 def gen_call(name: str,
  53              arg_type: Optional[QAPISchemaObjectType],
  54              boxed: bool,
  55              ret_type: Optional[QAPISchemaType]) -> str:
  56     ret = ''
  57
  58     argstr = ''
  59     if boxed:
  60         assert arg_type
  61         argstr = '&arg, '
  62     elif arg_type:
  63         assert not arg_type.variants
  64         for memb in arg_type.members:
  65             if memb.optional:
  66                 argstr += 'arg.has_%s, ' % c_name(memb.name)
  67             argstr += 'arg.%s, ' % c_name(memb.name)
  68
  69     lhs = ''
  70     if ret_type:
  71         lhs = 'retval = '
  72
  73     ret = mcgen('''
  74
  75     %(lhs)sqmp_%(c_name)s(%(args)s&err);
  76     error_propagate(errp, err);
  77 ''',
  78                 c_name=c_name(name), args=argstr, lhs=lhs)
  79     if ret_type:
  80         ret += mcgen('''
  81     if (err) {
  82         goto out;
  83     }
  84
  85     qmp_marshal_output_%(c_name)s(retval, ret, errp);
  86 ''',
  87                      c_name=ret_type.c_name())
  88     return ret
  89
  90
  91 def gen_marshal_output(ret_type: QAPISchemaType) -> str:
  92     return mcgen('''
  93
  94 static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in,
  95                                 QObject **ret_out, Error **errp)
  96 {
  97     Visitor *v;
  98
  99     v = qobject_output_visitor_new_qmp(ret_out);
 100     if (visit_type_%(c_name)s(v, "unused", &ret_in, errp)) {
 101         visit_complete(v, ret_out);
 102     }
 103     visit_free(v);
 104     v = qapi_dealloc_visitor_new();
 105     visit_type_%(c_name)s(v, "unused", &ret_in, NULL);
 106     visit_free(v);
 107 }
 108 ''',
 109                  c_type=ret_type.c_type(), c_name=ret_type.c_name())
 110
 111
 112 def build_marshal_proto(name: str) -> str:
 113     return ('void qmp_marshal_%s(QDict *args, QObject **ret, Error **errp)'
 114             % c_name(name))
 115
 116
 117 def gen_marshal_decl(name: str) -> str:
 118     return mcgen('''
 119 %(proto)s;
 120 ''',
 121                  proto=build_marshal_proto(name))
 122
 123
 124 def gen_marshal(name: str,
 125                 arg_type: Optional[QAPISchemaObjectType],
 126                 boxed: bool,
 127                 ret_type: Optional[QAPISchemaType]) -> str:
 128     have_args = boxed or (arg_type and not arg_type.is_empty())
 129     if have_args:
 130         assert arg_type is not None
 131         arg_type_c_name = arg_type.c_name()
 132
 133     ret = mcgen('''
 134
 135 %(proto)s
 136 {
 137     Error *err = NULL;
 138     bool ok = false;
 139     Visitor *v;
 140 ''',
 141                 proto=build_marshal_proto(name))
 142
 143     if ret_type:
 144         ret += mcgen('''
 145     %(c_type)s retval;
 146 ''',
 147                      c_type=ret_type.c_type())
 148
 149     if have_args:
 150         ret += mcgen('''
 151     %(c_name)s arg = {0};
 152 ''',
 153                      c_name=arg_type_c_name)
 154
 155     ret += mcgen('''
 156
 157     v = qobject_input_visitor_new_qmp(QOBJECT(args));
 158     if (!visit_start_struct(v, NULL, NULL, 0, errp)) {
 159         goto out;
 160     }
 161 ''')
 162
 163     if have_args:
 164         ret += mcgen('''
 165     if (visit_type_%(c_arg_type)s_members(v, &arg, errp)) {
 166         ok = visit_check_struct(v, errp);
 167     }
 168 ''',
 169                      c_arg_type=arg_type_c_name)
 170     else:
 171         ret += mcgen('''
 172     ok = visit_check_struct(v, errp);
 173 ''')
 174
 175     ret += mcgen('''
 176     visit_end_struct(v, NULL);
 177     if (!ok) {
 178         goto out;
 179     }
 180 ''')
 181
 182     ret += gen_call(name, arg_type, boxed, ret_type)
 183
 184     ret += mcgen('''
 185
 186 out:
 187     visit_free(v);
 188 ''')
 189
 190     ret += mcgen('''
 191     v = qapi_dealloc_visitor_new();
 192     visit_start_struct(v, NULL, NULL, 0, NULL);
 193 ''')
 194
 195     if have_args:
 196         ret += mcgen('''
 197     visit_type_%(c_arg_type)s_members(v, &arg, NULL);
 198 ''',
 199                      c_arg_type=arg_type_c_name)
 200
 201     ret += mcgen('''
 202     visit_end_struct(v, NULL);
 203     visit_free(v);
 204 ''')
 205
 206     ret += mcgen('''
 207 }
 208 ''')
 209     return ret
 210
 211
 212 def gen_register_command(name: str,
 213                          features: List[QAPISchemaFeature],
 214                          success_response: bool,
 215                          allow_oob: bool,
 216                          allow_preconfig: bool,
 217                          coroutine: bool) -> str:
 218     options = []
 219
 220     if 'deprecated' in [f.name for f in features]:
 221         options += ['QCO_DEPRECATED']
 222
 223     if not success_response:
 224         options += ['QCO_NO_SUCCESS_RESP']
 225     if allow_oob:
 226         options += ['QCO_ALLOW_OOB']
 227     if allow_preconfig:
 228         options += ['QCO_ALLOW_PRECONFIG']
 229     if coroutine:
 230         options += ['QCO_COROUTINE']
 231
 232     if not options:
 233         options = ['QCO_NO_OPTIONS']
 234
 235     ret = mcgen('''
 236     qmp_register_command(cmds, "%(name)s",
 237                          qmp_marshal_%(c_name)s, %(opts)s);
 238 ''',
 239                 name=name, c_name=c_name(name),
 240                 opts=" | ".join(options))
 241     return ret
 242
 243
 244 class QAPISchemaGenCommandVisitor(QAPISchemaModularCVisitor):
 245     def __init__(self, prefix: str):
 246         super().__init__(
 247             prefix, 'qapi-commands',
 248             ' * Schema-defined QAPI/QMP commands', None, __doc__)
 249         self._visited_ret_types: Dict[QAPIGenC, Set[QAPISchemaType]] = {}
 250
 251     def _begin_user_module(self, name: str) -> None:
 252         self._visited_ret_types[self._genc] = set()
 253         commands = self._module_basename('qapi-commands', name)
 254         types = self._module_basename('qapi-types', name)
 255         visit = self._module_basename('qapi-visit', name)
 256         self._genc.add(mcgen('''
 257 #include "qemu/osdep.h"
 258 #include "qapi/compat-policy.h"
 259 #include "qapi/visitor.h"
 260 #include "qapi/qmp/qdict.h"
 261 #include "qapi/dealloc-visitor.h"
 262 #include "qapi/error.h"
 263 #include "%(visit)s.h"
 264 #include "%(commands)s.h"
 265
 266 ''',
 267                              commands=commands, visit=visit))
 268         self._genh.add(mcgen('''
 269 #include "%(types)s.h"
 270
 271 ''',
 272                              types=types))
 273
 274     def visit_begin(self, schema: QAPISchema) -> None:
 275         self._add_module('./init', ' * QAPI Commands initialization')
 276         self._genh.add(mcgen('''
 277 #include "qapi/qmp/dispatch.h"
 278
 279 void %(c_prefix)sqmp_init_marshal(QmpCommandList *cmds);
 280 ''',
 281                              c_prefix=c_name(self._prefix, protect=False)))
 282         self._genc.add(mcgen('''
 283 #include "qemu/osdep.h"
 284 #include "%(prefix)sqapi-commands.h"
 285 #include "%(prefix)sqapi-init-commands.h"
 286
 287 void %(c_prefix)sqmp_init_marshal(QmpCommandList *cmds)
 288 {
 289     QTAILQ_INIT(cmds);
 290
 291 ''',
 292                              prefix=self._prefix,
 293                              c_prefix=c_name(self._prefix, protect=False)))
 294
 295     def visit_end(self) -> None:
 296         with self._temp_module('./init'):
 297             self._genc.add(mcgen('''
 298 }
 299 '''))
 300
 301     def visit_command(self,
 302                       name: str,
 303                       info: Optional[QAPISourceInfo],
 304                       ifcond: Sequence[str],
 305                       features: List[QAPISchemaFeature],
 306                       arg_type: Optional[QAPISchemaObjectType],
 307                       ret_type: Optional[QAPISchemaType],
 308                       gen: bool,
 309                       success_response: bool,
 310                       boxed: bool,
 311                       allow_oob: bool,
 312                       allow_preconfig: bool,
 313                       coroutine: bool) -> None:
 314         if not gen:
 315             return
 316         # FIXME: If T is a user-defined type, the user is responsible
 317         # for making this work, i.e. to make T's condition the
 318         # conjunction of the T-returning commands' conditions.  If T
 319         # is a built-in type, this isn't possible: the
 320         # qmp_marshal_output_T() will be generated unconditionally.
 321         if ret_type and ret_type not in self._visited_ret_types[self._genc]:
 322             self._visited_ret_types[self._genc].add(ret_type)
 323             with ifcontext(ret_type.ifcond,
 324                            self._genh, self._genc):
 325                 self._genc.add(gen_marshal_output(ret_type))
 326         with ifcontext(ifcond, self._genh, self._genc):
 327             self._genh.add(gen_command_decl(name, arg_type, boxed, ret_type))
 328             self._genh.add(gen_marshal_decl(name))
 329             self._genc.add(gen_marshal(name, arg_type, boxed, ret_type))
 330         with self._temp_module('./init'):
 331             with ifcontext(ifcond, self._genh, self._genc):
 332                 self._genc.add(gen_register_command(
 333                     name, features, success_response, allow_oob,
 334                     allow_preconfig, coroutine))
 335
 336
 337 def gen_commands(schema: QAPISchema,
 338                  output_dir: str,
 339                  prefix: str) -> None:
 340     vis = QAPISchemaGenCommandVisitor(prefix)
 341     schema.visit(vis)
 342     vis.write(output_dir)