scripts/qapi-commands.py

   1 #
   2 # QAPI command marshaller generator
   3 #
   4 # Copyright IBM, Corp. 2011
   5 # Copyright (C) 2014-2015 Red Hat, Inc.
   6 #
   7 # Authors:
   8 #  Anthony Liguori <[email protected]>
   9 #  Michael Roth    <[email protected]>
  10 #  Markus Armbruster <[email protected]>
  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 from ordereddict import OrderedDict
  16 from qapi import *
  17 import re
  18
  19 def generate_command_decl(name, args, ret_type):
  20     arglist=""
  21     for argname, argtype, optional in parse_args(args):
  22         argtype = c_type(argtype, is_param=True)
  23         if optional:
  24             arglist += "bool has_%s, " % c_name(argname)
  25         arglist += "%s %s, " % (argtype, c_name(argname))
  26     return mcgen('''
  27 %(ret_type)s qmp_%(name)s(%(args)sError **errp);
  28 ''',
  29                  ret_type=c_type(ret_type), name=c_name(name),
  30                  args=arglist).strip()
  31
  32 def gen_err_check(errvar):
  33     if errvar:
  34         return mcgen('''
  35 if (local_err) {
  36     goto out;
  37 }
  38 ''')
  39     return ''
  40
  41 def gen_sync_call(name, args, ret_type):
  42     ret = ""
  43     arglist=""
  44     retval=""
  45     if ret_type:
  46         retval = "retval = "
  47     for argname, argtype, optional in parse_args(args):
  48         if optional:
  49             arglist += "has_%s, " % c_name(argname)
  50         arglist += "%s, " % (c_name(argname))
  51     push_indent()
  52     ret = mcgen('''
  53 %(retval)sqmp_%(name)s(%(args)s&local_err);
  54
  55 ''',
  56                 name=c_name(name), args=arglist, retval=retval).rstrip()
  57     if ret_type:
  58         ret += "\n" + gen_err_check('local_err')
  59         ret += "\n" + mcgen('''
  60 %(marshal_output_call)s
  61 ''',
  62                             marshal_output_call=gen_marshal_output_call(name, ret_type)).rstrip()
  63     pop_indent()
  64     return ret.rstrip()
  65
  66
  67 def gen_marshal_output_call(name, ret_type):
  68     if not ret_type:
  69         return ""
  70     return "qmp_marshal_output_%s(retval, ret, &local_err);" % c_name(name)
  71
  72 def gen_visitor_input_containers_decl(args):
  73     ret = ""
  74
  75     push_indent()
  76     if len(args) > 0:
  77         ret += mcgen('''
  78 QmpInputVisitor *mi = qmp_input_visitor_new_strict(QOBJECT(args));
  79 QapiDeallocVisitor *md;
  80 Visitor *v;
  81 ''')
  82     pop_indent()
  83
  84     return ret.rstrip()
  85
  86 def gen_visitor_input_vars_decl(args):
  87     ret = ""
  88     push_indent()
  89     for argname, argtype, optional in parse_args(args):
  90         if optional:
  91             ret += mcgen('''
  92 bool has_%(argname)s = false;
  93 ''',
  94                          argname=c_name(argname))
  95         if is_c_ptr(argtype):
  96             ret += mcgen('''
  97 %(argtype)s %(argname)s = NULL;
  98 ''',
  99                          argname=c_name(argname), argtype=c_type(argtype))
 100         else:
 101             ret += mcgen('''
 102 %(argtype)s %(argname)s = {0};
 103 ''',
 104                          argname=c_name(argname), argtype=c_type(argtype))
 105
 106     pop_indent()
 107     return ret.rstrip()
 108
 109 def gen_visitor_input_block(args, dealloc=False):
 110     ret = ""
 111     errparg = '&local_err'
 112     errarg = 'local_err'
 113
 114     if len(args) == 0:
 115         return ret
 116
 117     push_indent()
 118
 119     if dealloc:
 120         errparg = 'NULL'
 121         errarg = None;
 122         ret += mcgen('''
 123 qmp_input_visitor_cleanup(mi);
 124 md = qapi_dealloc_visitor_new();
 125 v = qapi_dealloc_get_visitor(md);
 126 ''')
 127     else:
 128         ret += mcgen('''
 129 v = qmp_input_get_visitor(mi);
 130 ''')
 131
 132     for argname, argtype, optional in parse_args(args):
 133         if optional:
 134             ret += mcgen('''
 135 visit_optional(v, &has_%(c_name)s, "%(name)s", %(errp)s);
 136 ''',
 137                          c_name=c_name(argname), name=argname, errp=errparg)
 138             ret += gen_err_check(errarg)
 139             ret += mcgen('''
 140 if (has_%(c_name)s) {
 141 ''',
 142                          c_name=c_name(argname))
 143             push_indent()
 144         ret += mcgen('''
 145 visit_type_%(visitor)s(v, &%(c_name)s, "%(name)s", %(errp)s);
 146 ''',
 147                      c_name=c_name(argname), name=argname, argtype=argtype,
 148                      visitor=type_name(argtype), errp=errparg)
 149         ret += gen_err_check(errarg)
 150         if optional:
 151             pop_indent()
 152             ret += mcgen('''
 153 }
 154 ''')
 155
 156     if dealloc:
 157         ret += mcgen('''
 158 qapi_dealloc_visitor_cleanup(md);
 159 ''')
 160     pop_indent()
 161     return ret.rstrip()
 162
 163 def gen_marshal_output(name, ret_type):
 164     if not ret_type:
 165         return ""
 166
 167     ret = mcgen('''
 168 static void qmp_marshal_output_%(c_name)s(%(c_ret_type)s ret_in, QObject **ret_out, Error **errp)
 169 {
 170     Error *local_err = NULL;
 171     QmpOutputVisitor *mo = qmp_output_visitor_new();
 172     QapiDeallocVisitor *md;
 173     Visitor *v;
 174
 175     v = qmp_output_get_visitor(mo);
 176     visit_type_%(visitor)s(v, &ret_in, "unused", &local_err);
 177     if (local_err) {
 178         goto out;
 179     }
 180     *ret_out = qmp_output_get_qobject(mo);
 181
 182 out:
 183     error_propagate(errp, local_err);
 184     qmp_output_visitor_cleanup(mo);
 185     md = qapi_dealloc_visitor_new();
 186     v = qapi_dealloc_get_visitor(md);
 187     visit_type_%(visitor)s(v, &ret_in, "unused", NULL);
 188     qapi_dealloc_visitor_cleanup(md);
 189 }
 190 ''',
 191                 c_ret_type=c_type(ret_type), c_name=c_name(name),
 192                 visitor=type_name(ret_type))
 193
 194     return ret
 195
 196 def gen_marshal_input_decl(name, middle_mode):
 197     ret = 'void qmp_marshal_input_%s(QDict *args, QObject **ret, Error **errp)' % c_name(name)
 198     if not middle_mode:
 199         ret = "static " + ret
 200     return ret
 201
 202 def gen_marshal_input(name, args, ret_type, middle_mode):
 203     hdr = gen_marshal_input_decl(name, middle_mode)
 204
 205     ret = mcgen('''
 206 %(header)s
 207 {
 208     Error *local_err = NULL;
 209 ''',
 210                 header=hdr)
 211
 212     if ret_type:
 213         if is_c_ptr(ret_type):
 214             retval = "    %s retval = NULL;" % c_type(ret_type)
 215         else:
 216             retval = "    %s retval;" % c_type(ret_type)
 217         ret += mcgen('''
 218 %(retval)s
 219 ''',
 220                      retval=retval)
 221
 222     if len(args) > 0:
 223         ret += mcgen('''
 224 %(visitor_input_containers_decl)s
 225 %(visitor_input_vars_decl)s
 226
 227 %(visitor_input_block)s
 228
 229 ''',
 230                      visitor_input_containers_decl=gen_visitor_input_containers_decl(args),
 231                      visitor_input_vars_decl=gen_visitor_input_vars_decl(args),
 232                      visitor_input_block=gen_visitor_input_block(args))
 233     else:
 234         ret += mcgen('''
 235
 236     (void)args;
 237 ''')
 238
 239     ret += mcgen('''
 240 %(sync_call)s
 241 ''',
 242                  sync_call=gen_sync_call(name, args, ret_type))
 243     if re.search('^ *goto out\\;', ret, re.MULTILINE):
 244         ret += mcgen('''
 245
 246 out:
 247 ''')
 248     ret += mcgen('''
 249     error_propagate(errp, local_err);
 250 %(visitor_input_block_cleanup)s
 251 }
 252 ''',
 253                  visitor_input_block_cleanup=gen_visitor_input_block(args,
 254                                                                      dealloc=True))
 255     return ret
 256
 257 def gen_registry(commands):
 258     registry=""
 259     push_indent()
 260     for cmd in commands:
 261         options = 'QCO_NO_OPTIONS'
 262         if not cmd.get('success-response', True):
 263             options = 'QCO_NO_SUCCESS_RESP'
 264
 265         registry += mcgen('''
 266 qmp_register_command("%(name)s", qmp_marshal_input_%(c_name)s, %(opts)s);
 267 ''',
 268                      name=cmd['command'], c_name=c_name(cmd['command']),
 269                      opts=options)
 270     pop_indent()
 271     ret = mcgen('''
 272 static void qmp_init_marshal(void)
 273 {
 274 %(registry)s
 275 }
 276
 277 qapi_init(qmp_init_marshal);
 278 ''',
 279                 registry=registry.rstrip())
 280     return ret
 281
 282 middle_mode = False
 283
 284 (input_file, output_dir, do_c, do_h, prefix, opts) = \
 285     parse_command_line("m", ["middle"])
 286
 287 for o, a in opts:
 288     if o in ("-m", "--middle"):
 289         middle_mode = True
 290
 291 exprs = parse_schema(input_file)
 292 commands = filter(lambda expr: expr.has_key('command'), exprs)
 293 commands = filter(lambda expr: not expr.has_key('gen'), commands)
 294
 295 c_comment = '''
 296 /*
 297  * schema-defined QMP->QAPI command dispatch
 298  *
 299  * Copyright IBM, Corp. 2011
 300  *
 301  * Authors:
 302  *  Anthony Liguori   <[email protected]>
 303  *
 304  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 305  * See the COPYING.LIB file in the top-level directory.
 306  *
 307  */
 308 '''
 309 h_comment = '''
 310 /*
 311  * schema-defined QAPI function prototypes
 312  *
 313  * Copyright IBM, Corp. 2011
 314  *
 315  * Authors:
 316  *  Anthony Liguori   <[email protected]>
 317  *
 318  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 319  * See the COPYING.LIB file in the top-level directory.
 320  *
 321  */
 322 '''
 323
 324 (fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
 325                             'qmp-marshal.c', 'qmp-commands.h',
 326                             c_comment, h_comment)
 327
 328 fdef.write(mcgen('''
 329 #include "qemu-common.h"
 330 #include "qemu/module.h"
 331 #include "qapi/qmp/types.h"
 332 #include "qapi/qmp/dispatch.h"
 333 #include "qapi/visitor.h"
 334 #include "qapi/qmp-output-visitor.h"
 335 #include "qapi/qmp-input-visitor.h"
 336 #include "qapi/dealloc-visitor.h"
 337 #include "%(prefix)sqapi-types.h"
 338 #include "%(prefix)sqapi-visit.h"
 339 #include "%(prefix)sqmp-commands.h"
 340
 341 ''',
 342                 prefix=prefix))
 343
 344 fdecl.write(mcgen('''
 345 #include "%(prefix)sqapi-types.h"
 346 #include "qapi/qmp/qdict.h"
 347 #include "qapi/error.h"
 348
 349 ''',
 350                  prefix=prefix))
 351
 352 for cmd in commands:
 353     arglist = []
 354     ret_type = None
 355     if cmd.has_key('data'):
 356         arglist = cmd['data']
 357     if cmd.has_key('returns'):
 358         ret_type = cmd['returns']
 359     ret = generate_command_decl(cmd['command'], arglist, ret_type) + "\n"
 360     fdecl.write(ret)
 361     if ret_type:
 362         ret = gen_marshal_output(cmd['command'], ret_type) + "\n"
 363         fdef.write(ret)
 364
 365     if middle_mode:
 366         fdecl.write('%s;\n' % gen_marshal_input_decl(cmd['command'], middle_mode))
 367
 368     ret = gen_marshal_input(cmd['command'], arglist, ret_type, middle_mode) + "\n"
 369     fdef.write(ret)
 370
 371 if not middle_mode:
 372     ret = gen_registry(commands)
 373     fdef.write(ret)
 374
 375 close_output(fdef, fdecl)