qapi/qapi-visit-core.c

   1 /*
   2  * Core Definitions for QAPI Visitor Classes
   3  *
   4  * Copyright (C) 2012-2016 Red Hat, Inc.
   5  * Copyright IBM, Corp. 2011
   6  *
   7  * Authors:
   8  *  Anthony Liguori   <aliguori@us.ibm.com>
   9  *
  10  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  11  * See the COPYING.LIB file in the top-level directory.
  12  *
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include "qapi/error.h"
  17 #include "qapi/qmp/qerror.h"
  18 #include "qapi/visitor.h"
  19 #include "qapi/visitor-impl.h"
  20 #include "trace.h"
  21
  22 void visit_complete(Visitor *v, void *opaque)
  23 {
  24     assert(v->type != VISITOR_OUTPUT || v->complete);
  25     trace_visit_complete(v, opaque);
  26     if (v->complete) {
  27         v->complete(v, opaque);
  28     }
  29 }
  30
  31 void visit_free(Visitor *v)
  32 {
  33     trace_visit_free(v);
  34     if (v) {
  35         v->free(v);
  36     }
  37 }
  38
  39 void visit_start_struct(Visitor *v, const char *name, void **obj,
  40                         size_t size, Error **errp)
  41 {
  42     Error *err = NULL;
  43
  44     trace_visit_start_struct(v, name, obj, size);
  45     if (obj) {
  46         assert(size);
  47         assert(!(v->type & VISITOR_OUTPUT) || *obj);
  48     }
  49     v->start_struct(v, name, obj, size, &err);
  50     if (obj && (v->type & VISITOR_INPUT)) {
  51         assert(!err != !*obj);
  52     }
  53     error_propagate(errp, err);
  54 }
  55
  56 void visit_check_struct(Visitor *v, Error **errp)
  57 {
  58     trace_visit_check_struct(v);
  59     if (v->check_struct) {
  60         v->check_struct(v, errp);
  61     }
  62 }
  63
  64 void visit_end_struct(Visitor *v, void **obj)
  65 {
  66     trace_visit_end_struct(v, obj);
  67     v->end_struct(v, obj);
  68 }
  69
  70 void visit_start_list(Visitor *v, const char *name, GenericList **list,
  71                       size_t size, Error **errp)
  72 {
  73     Error *err = NULL;
  74
  75     assert(!list || size >= sizeof(GenericList));
  76     trace_visit_start_list(v, name, list, size);
  77     v->start_list(v, name, list, size, &err);
  78     if (list && (v->type & VISITOR_INPUT)) {
  79         assert(!(err && *list));
  80     }
  81     error_propagate(errp, err);
  82 }
  83
  84 GenericList *visit_next_list(Visitor *v, GenericList *tail, size_t size)
  85 {
  86     assert(tail && size >= sizeof(GenericList));
  87     trace_visit_next_list(v, tail, size);
  88     return v->next_list(v, tail, size);
  89 }
  90
  91 void visit_check_list(Visitor *v, Error **errp)
  92 {
  93     trace_visit_check_list(v);
  94     if (v->check_list) {
  95         v->check_list(v, errp);
  96     }
  97 }
  98
  99 void visit_end_list(Visitor *v, void **obj)
 100 {
 101     trace_visit_end_list(v, obj);
 102     v->end_list(v, obj);
 103 }
 104
 105 void visit_start_alternate(Visitor *v, const char *name,
 106                            GenericAlternate **obj, size_t size,
 107                            Error **errp)
 108 {
 109     Error *err = NULL;
 110
 111     assert(obj && size >= sizeof(GenericAlternate));
 112     assert(!(v->type & VISITOR_OUTPUT) || *obj);
 113     trace_visit_start_alternate(v, name, obj, size);
 114     if (v->start_alternate) {
 115         v->start_alternate(v, name, obj, size, &err);
 116     }
 117     if (v->type & VISITOR_INPUT) {
 118         assert(v->start_alternate && !err != !*obj);
 119     }
 120     error_propagate(errp, err);
 121 }
 122
 123 void visit_end_alternate(Visitor *v, void **obj)
 124 {
 125     trace_visit_end_alternate(v, obj);
 126     if (v->end_alternate) {
 127         v->end_alternate(v, obj);
 128     }
 129 }
 130
 131 bool visit_optional(Visitor *v, const char *name, bool *present)
 132 {
 133     trace_visit_optional(v, name, present);
 134     if (v->optional) {
 135         v->optional(v, name, present);
 136     }
 137     return *present;
 138 }
 139
 140 bool visit_is_input(Visitor *v)
 141 {
 142     return v->type == VISITOR_INPUT;
 143 }
 144
 145 bool visit_is_dealloc(Visitor *v)
 146 {
 147     return v->type == VISITOR_DEALLOC;
 148 }
 149
 150 void visit_type_int(Visitor *v, const char *name, int64_t *obj, Error **errp)
 151 {
 152     assert(obj);
 153     trace_visit_type_int(v, name, obj);
 154     v->type_int64(v, name, obj, errp);
 155 }
 156
 157 static void visit_type_uintN(Visitor *v, uint64_t *obj, const char *name,
 158                              uint64_t max, const char *type, Error **errp)
 159 {
 160     Error *err = NULL;
 161     uint64_t value = *obj;
 162
 163     assert(v->type == VISITOR_INPUT || value <= max);
 164
 165     v->type_uint64(v, name, &value, &err);
 166     if (err) {
 167         error_propagate(errp, err);
 168     } else if (value > max) {
 169         assert(v->type == VISITOR_INPUT);
 170         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 171                    name ? name : "null", type);
 172     } else {
 173         *obj = value;
 174     }
 175 }
 176
 177 void visit_type_uint8(Visitor *v, const char *name, uint8_t *obj,
 178                       Error **errp)
 179 {
 180     uint64_t value;
 181
 182     trace_visit_type_uint8(v, name, obj);
 183     value = *obj;
 184     visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp);
 185     *obj = value;
 186 }
 187
 188 void visit_type_uint16(Visitor *v, const char *name, uint16_t *obj,
 189                        Error **errp)
 190 {
 191     uint64_t value;
 192
 193     trace_visit_type_uint16(v, name, obj);
 194     value = *obj;
 195     visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp);
 196     *obj = value;
 197 }
 198
 199 void visit_type_uint32(Visitor *v, const char *name, uint32_t *obj,
 200                        Error **errp)
 201 {
 202     uint64_t value;
 203
 204     trace_visit_type_uint32(v, name, obj);
 205     value = *obj;
 206     visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp);
 207     *obj = value;
 208 }
 209
 210 void visit_type_uint64(Visitor *v, const char *name, uint64_t *obj,
 211                        Error **errp)
 212 {
 213     assert(obj);
 214     trace_visit_type_uint64(v, name, obj);
 215     v->type_uint64(v, name, obj, errp);
 216 }
 217
 218 static void visit_type_intN(Visitor *v, int64_t *obj, const char *name,
 219                             int64_t min, int64_t max, const char *type,
 220                             Error **errp)
 221 {
 222     Error *err = NULL;
 223     int64_t value = *obj;
 224
 225     assert(v->type == VISITOR_INPUT || (value >= min && value <= max));
 226
 227     v->type_int64(v, name, &value, &err);
 228     if (err) {
 229         error_propagate(errp, err);
 230     } else if (value < min || value > max) {
 231         assert(v->type == VISITOR_INPUT);
 232         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 233                    name ? name : "null", type);
 234     } else {
 235         *obj = value;
 236     }
 237 }
 238
 239 void visit_type_int8(Visitor *v, const char *name, int8_t *obj, Error **errp)
 240 {
 241     int64_t value;
 242
 243     trace_visit_type_int8(v, name, obj);
 244     value = *obj;
 245     visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp);
 246     *obj = value;
 247 }
 248
 249 void visit_type_int16(Visitor *v, const char *name, int16_t *obj,
 250                       Error **errp)
 251 {
 252     int64_t value;
 253
 254     trace_visit_type_int16(v, name, obj);
 255     value = *obj;
 256     visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t", errp);
 257     *obj = value;
 258 }
 259
 260 void visit_type_int32(Visitor *v, const char *name, int32_t *obj,
 261                       Error **errp)
 262 {
 263     int64_t value;
 264
 265     trace_visit_type_int32(v, name, obj);
 266     value = *obj;
 267     visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t", errp);
 268     *obj = value;
 269 }
 270
 271 void visit_type_int64(Visitor *v, const char *name, int64_t *obj,
 272                       Error **errp)
 273 {
 274     assert(obj);
 275     trace_visit_type_int64(v, name, obj);
 276     v->type_int64(v, name, obj, errp);
 277 }
 278
 279 void visit_type_size(Visitor *v, const char *name, uint64_t *obj,
 280                      Error **errp)
 281 {
 282     assert(obj);
 283     trace_visit_type_size(v, name, obj);
 284     if (v->type_size) {
 285         v->type_size(v, name, obj, errp);
 286     } else {
 287         v->type_uint64(v, name, obj, errp);
 288     }
 289 }
 290
 291 void visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
 292 {
 293     assert(obj);
 294     trace_visit_type_bool(v, name, obj);
 295     v->type_bool(v, name, obj, errp);
 296 }
 297
 298 void visit_type_str(Visitor *v, const char *name, char **obj, Error **errp)
 299 {
 300     Error *err = NULL;
 301
 302     assert(obj);
 303     /* TODO: Fix callers to not pass NULL when they mean "", so that we
 304      * can enable:
 305     assert(!(v->type & VISITOR_OUTPUT) || *obj);
 306      */
 307     trace_visit_type_str(v, name, obj);
 308     v->type_str(v, name, obj, &err);
 309     if (v->type & VISITOR_INPUT) {
 310         assert(!err != !*obj);
 311     }
 312     error_propagate(errp, err);
 313 }
 314
 315 void visit_type_number(Visitor *v, const char *name, double *obj,
 316                        Error **errp)
 317 {
 318     assert(obj);
 319     trace_visit_type_number(v, name, obj);
 320     v->type_number(v, name, obj, errp);
 321 }
 322
 323 void visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp)
 324 {
 325     Error *err = NULL;
 326
 327     assert(obj);
 328     assert(v->type != VISITOR_OUTPUT || *obj);
 329     trace_visit_type_any(v, name, obj);
 330     v->type_any(v, name, obj, &err);
 331     if (v->type == VISITOR_INPUT) {
 332         assert(!err != !*obj);
 333     }
 334     error_propagate(errp, err);
 335 }
 336
 337 void visit_type_null(Visitor *v, const char *name, QNull **obj,
 338                      Error **errp)
 339 {
 340     trace_visit_type_null(v, name, obj);
 341     v->type_null(v, name, obj, errp);
 342 }
 343
 344 static void output_type_enum(Visitor *v, const char *name, int *obj,
 345                              const QEnumLookup *lookup, Error **errp)
 346 {
 347     int value = *obj;
 348     char *enum_str;
 349
 350     enum_str = (char *)qapi_enum_lookup(lookup, value);
 351     visit_type_str(v, name, &enum_str, errp);
 352 }
 353
 354 static void input_type_enum(Visitor *v, const char *name, int *obj,
 355                             const QEnumLookup *lookup, Error **errp)
 356 {
 357     Error *local_err = NULL;
 358     int64_t value;
 359     char *enum_str;
 360
 361     visit_type_str(v, name, &enum_str, &local_err);
 362     if (local_err) {
 363         error_propagate(errp, local_err);
 364         return;
 365     }
 366
 367     value = qapi_enum_parse(lookup, enum_str, -1, NULL);
 368     if (value < 0) {
 369         error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
 370         g_free(enum_str);
 371         return;
 372     }
 373
 374     g_free(enum_str);
 375     *obj = value;
 376 }
 377
 378 void visit_type_enum(Visitor *v, const char *name, int *obj,
 379                      const QEnumLookup *lookup, Error **errp)
 380 {
 381     assert(obj && lookup);
 382     trace_visit_type_enum(v, name, obj);
 383     switch (v->type) {
 384     case VISITOR_INPUT:
 385         input_type_enum(v, name, obj, lookup, errp);
 386         break;
 387     case VISITOR_OUTPUT:
 388         output_type_enum(v, name, obj, lookup, errp);
 389         break;
 390     case VISITOR_CLONE:
 391         /* nothing further to do, scalar value was already copied by
 392          * g_memdup() during visit_start_*() */
 393         break;
 394     case VISITOR_DEALLOC:
 395         /* nothing to deallocate for a scalar */
 396         break;
 397     }
 398 }