static void test_visitor_in_null(TestInputVisitorData *data, const void *unused) { Visitor *v; Error *err = NULL; char *tmp; /* * FIXME: Since QAPI doesn't know the 'null' type yet, we can't * test visit_type_null() by reading into a QAPI struct then * checking that it was populated correctly. The best we can do * for now is ensure that we consumed null from the input, proven * by the fact that we can't re-read the key; and that we detect * when input is not null. */ v = visitor_input_test_init(data, "{ 'a': null, 'b': '' }"); visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_type_null(v, "a", &error_abort); visit_type_str(v, "a", &tmp, &err); g_assert(!tmp); error_free_or_abort(&err); visit_type_null(v, "b", &err); error_free_or_abort(&err); visit_check_struct(v, &error_abort); visit_end_struct(v, NULL); }
static void balloon_stats_get_all(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp) { Error *err = NULL; VirtIOBalloon *s = opaque; int i; visit_start_struct(v, name, NULL, 0, &err); if (err) { goto out; } visit_type_int(v, "last-update", &s->stats_last_update, &err); if (err) { goto out_end; } visit_start_struct(v, "stats", NULL, 0, &err); if (err) { goto out_end; } for (i = 0; i < VIRTIO_BALLOON_S_NR; i++) { visit_type_uint64(v, balloon_stat_names[i], &s->stats[i], &err); if (err) { goto out_nested; } } visit_check_struct(v, &err); out_nested: visit_end_struct(v, NULL); if (!err) { visit_check_struct(v, &err); } out_end: visit_end_struct(v, NULL); out: error_propagate(errp, err); }
Object *user_creatable_add(const QDict *qdict, Visitor *v, Error **errp) { char *type = NULL; char *id = NULL; Object *obj = NULL; Error *local_err = NULL; QDict *pdict; pdict = qdict_clone_shallow(qdict); visit_start_struct(v, NULL, NULL, 0, &local_err); if (local_err) { goto out; } qdict_del(pdict, "qom-type"); visit_type_str(v, "qom-type", &type, &local_err); if (local_err) { goto out_visit; } qdict_del(pdict, "id"); visit_type_str(v, "id", &id, &local_err); if (local_err) { goto out_visit; } visit_check_struct(v, &local_err); if (local_err) { goto out_visit; } obj = user_creatable_add_type(type, id, pdict, v, &local_err); out_visit: visit_end_struct(v, NULL); out: QDECREF(pdict); g_free(id); g_free(type); if (local_err) { error_propagate(errp, local_err); object_unref(obj); return NULL; } return obj; }
static QCryptoBlockCreateOptions * block_crypto_create_opts_init(QCryptoBlockFormat format, QemuOpts *opts, Error **errp) { OptsVisitor *ov; QCryptoBlockCreateOptions *ret = NULL; Error *local_err = NULL; ret = g_new0(QCryptoBlockCreateOptions, 1); ret->format = format; ov = opts_visitor_new(opts); visit_start_struct(opts_get_visitor(ov), NULL, NULL, 0, &local_err); if (local_err) { goto out; } switch (format) { case Q_CRYPTO_BLOCK_FORMAT_LUKS: visit_type_QCryptoBlockCreateOptionsLUKS_members( opts_get_visitor(ov), &ret->u.luks, &local_err); break; default: error_setg(&local_err, "Unsupported block format %d", format); break; } if (!local_err) { visit_check_struct(opts_get_visitor(ov), &local_err); } visit_end_struct(opts_get_visitor(ov)); out: if (local_err) { error_propagate(errp, local_err); qapi_free_QCryptoBlockCreateOptions(ret); ret = NULL; } opts_visitor_cleanup(ov); return ret; }
Object *user_creatable_add_type(const char *type, const char *id, const QDict *qdict, Visitor *v, Error **errp) { Object *obj; ObjectClass *klass; const QDictEntry *e; Error *local_err = NULL; klass = object_class_by_name(type); if (!klass) { error_setg(errp, "invalid object type: %s", type); return NULL; } if (!object_class_dynamic_cast(klass, TYPE_USER_CREATABLE)) { error_setg(errp, "object type '%s' isn't supported by object-add", type); return NULL; } if (object_class_is_abstract(klass)) { error_setg(errp, "object type '%s' is abstract", type); return NULL; } assert(qdict); obj = object_new(type); visit_start_struct(v, NULL, NULL, 0, &local_err); if (local_err) { goto out; } for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { object_property_set(obj, v, e->key, &local_err); if (local_err) { break; } } if (!local_err) { visit_check_struct(v, &local_err); } visit_end_struct(v, NULL); if (local_err) { goto out; } if (id != NULL) { object_property_add_child(object_get_objects_root(), id, obj, &local_err); if (local_err) { goto out; } } user_creatable_complete(USER_CREATABLE(obj), &local_err); if (local_err) { if (id != NULL) { object_property_del(object_get_objects_root(), id, &error_abort); } goto out; } out: if (local_err) { error_propagate(errp, local_err); object_unref(obj); return NULL; } return obj; }
static void cpu_model_from_info(S390CPUModel *model, const CpuModelInfo *info, Error **errp) { const QDict *qdict = NULL; const QDictEntry *e; Visitor *visitor; ObjectClass *oc; S390CPU *cpu; Object *obj; if (info->props) { qdict = qobject_to_qdict(info->props); if (!qdict) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict"); return; } } oc = cpu_class_by_name(TYPE_S390_CPU, info->name); if (!oc) { error_setg(errp, "The CPU definition \'%s\' is unknown.", info->name); return; } if (S390_CPU_CLASS(oc)->kvm_required && !kvm_enabled()) { error_setg(errp, "The CPU definition '%s' requires KVM", info->name); return; } obj = object_new(object_class_get_name(oc)); cpu = S390_CPU(obj); if (!cpu->model) { error_setg(errp, "Details about the host CPU model are not available, " "it cannot be used."); object_unref(obj); return; } if (qdict) { visitor = qobject_input_visitor_new(info->props); visit_start_struct(visitor, NULL, NULL, 0, errp); if (*errp) { object_unref(obj); return; } for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { object_property_set(obj, visitor, e->key, errp); if (*errp) { break; } } if (!*errp) { visit_check_struct(visitor, errp); } visit_end_struct(visitor, NULL); visit_free(visitor); if (*errp) { object_unref(obj); return; } } /* copy the model and throw the cpu away */ memcpy(model, cpu->model, sizeof(*model)); object_unref(obj); }
static void prop_get_fdt(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp) { sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); Error *err = NULL; int fdt_offset_next, fdt_offset, fdt_depth; void *fdt; if (!drc->fdt) { visit_type_null(v, NULL, errp); return; } fdt = drc->fdt; fdt_offset = drc->fdt_start_offset; fdt_depth = 0; do { const char *name = NULL; const struct fdt_property *prop = NULL; int prop_len = 0, name_len = 0; uint32_t tag; tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next); switch (tag) { case FDT_BEGIN_NODE: fdt_depth++; name = fdt_get_name(fdt, fdt_offset, &name_len); visit_start_struct(v, name, NULL, 0, &err); if (err) { error_propagate(errp, err); return; } break; case FDT_END_NODE: /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */ g_assert(fdt_depth > 0); visit_check_struct(v, &err); visit_end_struct(v, NULL); if (err) { error_propagate(errp, err); return; } fdt_depth--; break; case FDT_PROP: { int i; prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len); name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff)); visit_start_list(v, name, NULL, 0, &err); if (err) { error_propagate(errp, err); return; } for (i = 0; i < prop_len; i++) { visit_type_uint8(v, NULL, (uint8_t *)&prop->data[i], &err); if (err) { error_propagate(errp, err); return; } } visit_end_list(v, NULL); break; } default: error_setg(&error_abort, "device FDT in unexpected state: %d", tag); } fdt_offset = fdt_offset_next; } while (fdt_depth != 0); }