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