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