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 import sys
  19 import os
  20 import getopt
  21 import errno
  22
  23 def type_visitor(name):
  24     if type(name) == list:
  25         return 'visit_type_%sList' % name[0]
  26     else:
  27         return 'visit_type_%s' % name
  28
  29 def generate_command_decl(name, args, ret_type):
  30     arglist=""
  31     for argname, argtype, optional in parse_args(args):
  32         argtype = c_type(argtype, is_param=True)
  33         if optional:
  34             arglist += "bool has_%s, " % c_var(argname)
  35         arglist += "%s %s, " % (argtype, c_var(argname))
  36     return mcgen('''
  37 %(ret_type)s qmp_%(name)s(%(args)sError **errp);
  38 ''',
  39                  ret_type=c_type(ret_type), name=c_fun(name), args=arglist).strip()
  40
  41 def gen_err_check(errvar):
  42     if errvar:
  43         return mcgen('''
  44 if (local_err) {
  45     goto out;
  46 }
  47 ''')
  48     return ''
  49
  50 def gen_sync_call(name, args, ret_type, indent=0):
  51     ret = ""
  52     arglist=""
  53     retval=""
  54     if ret_type:
  55         retval = "retval = "
  56     for argname, argtype, optional in parse_args(args):
  57         if optional:
  58             arglist += "has_%s, " % c_var(argname)
  59         arglist += "%s, " % (c_var(argname))
  60     push_indent(indent)
  61     ret = mcgen('''
  62 %(retval)sqmp_%(name)s(%(args)s&local_err);
  63
  64 ''',
  65                 name=c_fun(name), args=arglist, retval=retval).rstrip()
  66     if ret_type:
  67         ret += "\n" + gen_err_check('local_err')
  68         ret += "\n" + mcgen(''''
  69 %(marshal_output_call)s
  70 ''',
  71                             marshal_output_call=gen_marshal_output_call(name, ret_type)).rstrip()
  72     pop_indent(indent)
  73     return ret.rstrip()
  74
  75
  76 def gen_marshal_output_call(name, ret_type):
  77     if not ret_type:
  78         return ""
  79     return "qmp_marshal_output_%s(retval, ret, &local_err);" % c_fun(name)
  80
  81 def gen_visitor_input_containers_decl(args, obj):
  82     ret = ""
  83
  84     push_indent()
  85     if len(args) > 0:
  86         ret += mcgen('''
  87 QmpInputVisitor *mi = qmp_input_visitor_new_strict(%(obj)s);
  88 QapiDeallocVisitor *md;
  89 Visitor *v;
  90 ''',
  91                      obj=obj)
  92     pop_indent()
  93
  94     return ret.rstrip()
  95
  96 def gen_visitor_input_vars_decl(args):
  97     ret = ""
  98     push_indent()
  99     for argname, argtype, optional in parse_args(args):
 100         if optional:
 101             ret += mcgen('''
 102 bool has_%(argname)s = false;
 103 ''',
 104                          argname=c_var(argname))
 105         if is_c_ptr(argtype):
 106             ret += mcgen('''
 107 %(argtype)s %(argname)s = NULL;
 108 ''',
 109                          argname=c_var(argname), argtype=c_type(argtype))
 110         else:
 111             ret += mcgen('''
 112 %(argtype)s %(argname)s = {0};
 113 ''',
 114                          argname=c_var(argname), argtype=c_type(argtype))
 115
 116     pop_indent()
 117     return ret.rstrip()
 118
 119 def gen_visitor_input_block(args, dealloc=False):
 120     ret = ""
 121     errparg = '&local_err'
 122     errarg = 'local_err'
 123
 124     if len(args) == 0:
 125         return ret
 126
 127     push_indent()
 128
 129     if dealloc:
 130         errparg = 'NULL'
 131         errarg = None;
 132         ret += mcgen('''
 133 qmp_input_visitor_cleanup(mi);
 134 md = qapi_dealloc_visitor_new();
 135 v = qapi_dealloc_get_visitor(md);
 136 ''')
 137     else:
 138         ret += mcgen('''
 139 v = qmp_input_get_visitor(mi);
 140 ''')
 141
 142     for argname, argtype, optional in parse_args(args):
 143         if optional:
 144             ret += mcgen('''
 145 visit_optional(v, &has_%(c_name)s, "%(name)s", %(errp)s);
 146 ''',
 147                          c_name=c_var(argname), name=argname, errp=errparg)
 148             ret += gen_err_check(errarg)
 149             ret += mcgen('''
 150 if (has_%(c_name)s) {
 151 ''',
 152                          c_name=c_var(argname))
 153             push_indent()
 154         ret += mcgen('''
 155 %(visitor)s(v, &%(c_name)s, "%(name)s", %(errp)s);
 156 ''',
 157                      c_name=c_var(argname), name=argname, argtype=argtype,
 158                      visitor=type_visitor(argtype), errp=errparg)
 159         ret += gen_err_check(errarg)
 160         if optional:
 161             pop_indent()
 162             ret += mcgen('''
 163 }
 164 ''')
 165
 166     if dealloc:
 167         ret += mcgen('''
 168 qapi_dealloc_visitor_cleanup(md);
 169 ''')
 170     pop_indent()
 171     return ret.rstrip()
 172
 173 def gen_marshal_output(name, args, ret_type, middle_mode):
 174     if not ret_type:
 175         return ""
 176
 177     ret = mcgen('''
 178 static void qmp_marshal_output_%(c_name)s(%(c_ret_type)s ret_in, QObject **ret_out, Error **errp)
 179 {
 180     Error *local_err = NULL;
 181     QmpOutputVisitor *mo = qmp_output_visitor_new();
 182     QapiDeallocVisitor *md;
 183     Visitor *v;
 184
 185     v = qmp_output_get_visitor(mo);
 186     %(visitor)s(v, &ret_in, "unused", &local_err);
 187     if (local_err) {
 188         goto out;
 189     }
 190     *ret_out = qmp_output_get_qobject(mo);
 191
 192 out:
 193     error_propagate(errp, local_err);
 194     qmp_output_visitor_cleanup(mo);
 195     md = qapi_dealloc_visitor_new();
 196     v = qapi_dealloc_get_visitor(md);
 197     %(visitor)s(v, &ret_in, "unused", NULL);
 198     qapi_dealloc_visitor_cleanup(md);
 199 }
 200 ''',
 201                 c_ret_type=c_type(ret_type), c_name=c_fun(name),
 202                 visitor=type_visitor(ret_type))
 203
 204     return ret
 205
 206 def gen_marshal_input_decl(name, args, ret_type, middle_mode):
 207     if middle_mode:
 208         return 'int qmp_marshal_input_%s(Monitor *mon, const QDict *qdict, QObject **ret)' % c_fun(name)
 209     else:
 210         return 'static void qmp_marshal_input_%s(QDict *args, QObject **ret, Error **errp)' % c_fun(name)
 211
 212
 213
 214 def gen_marshal_input(name, args, ret_type, middle_mode):
 215     hdr = gen_marshal_input_decl(name, args, ret_type, middle_mode)
 216
 217     ret = mcgen('''
 218 %(header)s
 219 {
 220     Error *local_err = NULL;
 221 ''',
 222                 header=hdr)
 223
 224     if middle_mode:
 225         ret += mcgen('''
 226     QDict *args = (QDict *)qdict;
 227 ''')
 228
 229     if ret_type:
 230         if is_c_ptr(ret_type):
 231             retval = "    %s retval = NULL;" % c_type(ret_type)
 232         else:
 233             retval = "    %s retval;" % c_type(ret_type)
 234         ret += mcgen('''
 235 %(retval)s
 236 ''',
 237                      retval=retval)
 238
 239     if len(args) > 0:
 240         ret += mcgen('''
 241 %(visitor_input_containers_decl)s
 242 %(visitor_input_vars_decl)s
 243
 244 %(visitor_input_block)s
 245
 246 ''',
 247                      visitor_input_containers_decl=gen_visitor_input_containers_decl(args, "QOBJECT(args)"),
 248                      visitor_input_vars_decl=gen_visitor_input_vars_decl(args),
 249                      visitor_input_block=gen_visitor_input_block(args))
 250     else:
 251         ret += mcgen('''
 252
 253     (void)args;
 254 ''')
 255
 256     ret += mcgen('''
 257 %(sync_call)s
 258 ''',
 259                  sync_call=gen_sync_call(name, args, ret_type, indent=4))
 260     if re.search('^ *goto out\\;', ret, re.MULTILINE):
 261         ret += mcgen('''
 262
 263 out:
 264 ''')
 265     if not middle_mode:
 266         ret += mcgen('''
 267     error_propagate(errp, local_err);
 268 ''')
 269     ret += mcgen('''
 270 %(visitor_input_block_cleanup)s
 271 ''',
 272                  visitor_input_block_cleanup=gen_visitor_input_block(args,
 273                                                                      dealloc=True))
 274
 275     if middle_mode:
 276         ret += mcgen('''
 277
 278     if (local_err) {
 279         qerror_report_err(local_err);
 280         error_free(local_err);
 281         return -1;
 282     }
 283     return 0;
 284 ''')
 285     else:
 286         ret += mcgen('''
 287     return;
 288 ''')
 289
 290     ret += mcgen('''
 291 }
 292 ''')
 293
 294     return ret
 295
 296 def gen_registry(commands):
 297     registry=""
 298     push_indent()
 299     for cmd in commands:
 300         options = 'QCO_NO_OPTIONS'
 301         if not cmd.get('success-response', True):
 302             options = 'QCO_NO_SUCCESS_RESP'
 303
 304         registry += mcgen('''
 305 qmp_register_command("%(name)s", qmp_marshal_input_%(c_name)s, %(opts)s);
 306 ''',
 307                      name=cmd['command'], c_name=c_fun(cmd['command']),
 308                      opts=options)
 309     pop_indent()
 310     ret = mcgen('''
 311 static void qmp_init_marshal(void)
 312 {
 313 %(registry)s
 314 }
 315
 316 qapi_init(qmp_init_marshal);
 317 ''',
 318                 registry=registry.rstrip())
 319     return ret
 320
 321 def gen_command_decl_prologue(header, guard, prefix=""):
 322     ret = mcgen('''
 323 /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
 324
 325 /*
 326  * schema-defined QAPI function prototypes
 327  *
 328  * Copyright IBM, Corp. 2011
 329  *
 330  * Authors:
 331  *  Anthony Liguori   <[email protected]>
 332  *
 333  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 334  * See the COPYING.LIB file in the top-level directory.
 335  *
 336  */
 337
 338 #ifndef %(guard)s
 339 #define %(guard)s
 340
 341 #include "%(prefix)sqapi-types.h"
 342 #include "qapi/qmp/qdict.h"
 343 #include "qapi/error.h"
 344
 345 ''',
 346                  header=basename(header), guard=guardname(header), prefix=prefix)
 347     return ret
 348
 349 def gen_command_def_prologue(prefix="", proxy=False):
 350     ret = mcgen('''
 351 /* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT MODIFY */
 352
 353 /*
 354  * schema-defined QMP->QAPI command dispatch
 355  *
 356  * Copyright IBM, Corp. 2011
 357  *
 358  * Authors:
 359  *  Anthony Liguori   <[email protected]>
 360  *
 361  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 362  * See the COPYING.LIB file in the top-level directory.
 363  *
 364  */
 365
 366 #include "qemu-common.h"
 367 #include "qemu/module.h"
 368 #include "qapi/qmp/qerror.h"
 369 #include "qapi/qmp/types.h"
 370 #include "qapi/qmp/dispatch.h"
 371 #include "qapi/visitor.h"
 372 #include "qapi/qmp-output-visitor.h"
 373 #include "qapi/qmp-input-visitor.h"
 374 #include "qapi/dealloc-visitor.h"
 375 #include "%(prefix)sqapi-types.h"
 376 #include "%(prefix)sqapi-visit.h"
 377
 378 ''',
 379                 prefix=prefix)
 380     if not proxy:
 381         ret += '#include "%sqmp-commands.h"' % prefix
 382     return ret + "\n\n"
 383
 384
 385 try:
 386     opts, args = getopt.gnu_getopt(sys.argv[1:], "chp:i:o:m",
 387                                    ["source", "header", "prefix=",
 388                                     "input-file=", "output-dir=",
 389                                     "type=", "middle"])
 390 except getopt.GetoptError, err:
 391     print str(err)
 392     sys.exit(1)
 393
 394 output_dir = ""
 395 prefix = ""
 396 dispatch_type = "sync"
 397 c_file = 'qmp-marshal.c'
 398 h_file = 'qmp-commands.h'
 399 middle_mode = False
 400
 401 do_c = False
 402 do_h = False
 403
 404 for o, a in opts:
 405     if o in ("-p", "--prefix"):
 406         prefix = a
 407     elif o in ("-i", "--input-file"):
 408         input_file = a
 409     elif o in ("-o", "--output-dir"):
 410         output_dir = a + "/"
 411     elif o in ("-t", "--type"):
 412         dispatch_type = a
 413     elif o in ("-m", "--middle"):
 414         middle_mode = True
 415     elif o in ("-c", "--source"):
 416         do_c = True
 417     elif o in ("-h", "--header"):
 418         do_h = True
 419
 420 if not do_c and not do_h:
 421     do_c = True
 422     do_h = True
 423
 424 c_file = output_dir + prefix + c_file
 425 h_file = output_dir + prefix + h_file
 426
 427 def maybe_open(really, name, opt):
 428     if really:
 429         return open(name, opt)
 430     else:
 431         import StringIO
 432         return StringIO.StringIO()
 433
 434 try:
 435     os.makedirs(output_dir)
 436 except os.error, e:
 437     if e.errno != errno.EEXIST:
 438         raise
 439
 440 exprs = parse_schema(input_file)
 441 commands = filter(lambda expr: expr.has_key('command'), exprs)
 442 commands = filter(lambda expr: not expr.has_key('gen'), commands)
 443
 444 if dispatch_type == "sync":
 445     fdecl = maybe_open(do_h, h_file, 'w')
 446     fdef = maybe_open(do_c, c_file, 'w')
 447     ret = gen_command_decl_prologue(header=basename(h_file), guard=guardname(h_file), prefix=prefix)
 448     fdecl.write(ret)
 449     ret = gen_command_def_prologue(prefix=prefix)
 450     fdef.write(ret)
 451
 452     for cmd in commands:
 453         arglist = []
 454         ret_type = None
 455         if cmd.has_key('data'):
 456             arglist = cmd['data']
 457         if cmd.has_key('returns'):
 458             ret_type = cmd['returns']
 459         ret = generate_command_decl(cmd['command'], arglist, ret_type) + "\n"
 460         fdecl.write(ret)
 461         if ret_type:
 462             ret = gen_marshal_output(cmd['command'], arglist, ret_type, middle_mode) + "\n"
 463             fdef.write(ret)
 464
 465         if middle_mode:
 466             fdecl.write('%s;\n' % gen_marshal_input_decl(cmd['command'], arglist, ret_type, middle_mode))
 467
 468         ret = gen_marshal_input(cmd['command'], arglist, ret_type, middle_mode) + "\n"
 469         fdef.write(ret)
 470
 471     fdecl.write("\n#endif\n");
 472
 473     if not middle_mode:
 474         ret = gen_registry(commands)
 475         fdef.write(ret)
 476
 477     fdef.flush()
 478     fdef.close()
 479     fdecl.flush()
 480     fdecl.close()