void visit_type_VncInfo(Visitor *m, VncInfo ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "VncInfo", name, sizeof(VncInfo), errp);
visit_type_bool(m, (obj && *obj) ? &(*obj)->enabled : NULL, "enabled", errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_host : NULL, "host", errp);
if ((*obj)->has_host) {
visit_type_str(m, (obj && *obj) ? &(*obj)->host : NULL, "host", errp);
}
visit_end_optional(m, errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_family : NULL, "family", errp);
if ((*obj)->has_family) {
visit_type_str(m, (obj && *obj) ? &(*obj)->family : NULL, "family", errp);
}
visit_end_optional(m, errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_service : NULL, "service", errp);
if ((*obj)->has_service) {
visit_type_str(m, (obj && *obj) ? &(*obj)->service : NULL, "service", errp);
}
visit_end_optional(m, errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_auth : NULL, "auth", errp);
if ((*obj)->has_auth) {
visit_type_str(m, (obj && *obj) ? &(*obj)->auth : NULL, "auth", errp);
}
visit_end_optional(m, errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_clients : NULL, "clients", errp);
if ((*obj)->has_clients) {
visit_type_VncClientInfoList(m, (obj && *obj) ? &(*obj)->clients : NULL, "clients", errp);
}
visit_end_optional(m, errp);
visit_end_struct(m, errp);
}
void visit_type_PciDeviceInfo(Visitor *m, PciDeviceInfo ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "PciDeviceInfo", name, sizeof(PciDeviceInfo), errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->bus : NULL, "bus", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->slot : NULL, "slot", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->function : NULL, "function", errp);
visit_start_struct(m, NULL, "", "class_info", 0, errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->class_info.has_desc : NULL, "desc", errp);
if ((*obj)->class_info.has_desc) {
visit_type_str(m, (obj && *obj) ? &(*obj)->class_info.desc : NULL, "desc", errp);
}
visit_end_optional(m, errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->class_info.class : NULL, "class", errp);
visit_end_struct(m, errp);
visit_start_struct(m, NULL, "", "id", 0, errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->id.device : NULL, "device", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->id.vendor : NULL, "vendor", errp);
visit_end_struct(m, errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_irq : NULL, "irq", errp);
if ((*obj)->has_irq) {
visit_type_int(m, (obj && *obj) ? &(*obj)->irq : NULL, "irq", errp);
}
visit_end_optional(m, errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->qdev_id : NULL, "qdev_id", errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_pci_bridge : NULL, "pci_bridge", errp);
if ((*obj)->has_pci_bridge) {
visit_type_PciBridgeInfo(m, (obj && *obj) ? &(*obj)->pci_bridge : NULL, "pci_bridge", errp);
}
visit_end_optional(m, errp);
visit_type_PciMemoryRegionList(m, (obj && *obj) ? &(*obj)->regions : NULL, "regions", errp);
visit_end_struct(m, errp);
}
void visit_type_ChardevInfo(Visitor *m, ChardevInfo ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "ChardevInfo", name, sizeof(ChardevInfo), errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->label : NULL, "label", errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->filename : NULL, "filename", errp);
visit_end_struct(m, errp);
}
void visit_type_SpiceChannel(Visitor *m, SpiceChannel ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "SpiceChannel", name, sizeof(SpiceChannel), errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->host : NULL, "host", errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->family : NULL, "family", errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->port : NULL, "port", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->connection_id : NULL, "connection-id", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->channel_type : NULL, "channel-type", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->channel_id : NULL, "channel-id", errp);
visit_type_bool(m, (obj && *obj) ? &(*obj)->tls : NULL, "tls", errp);
visit_end_struct(m, errp);
}
static void get_string(DeviceState *dev, Visitor *v, void *opaque,
const char *name, Error **errp)
{
Property *prop = opaque;
char **ptr = qdev_get_prop_ptr(dev, prop);
if (!*ptr) {
char *str = (char *)"";
visit_type_str(v, &str, name, errp);
} else {
visit_type_str(v, ptr, name, errp);
}
}
void visit_type_BlockDeviceInfo(Visitor *m, BlockDeviceInfo ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "BlockDeviceInfo", name, sizeof(BlockDeviceInfo), errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->file : NULL, "file", errp);
visit_type_bool(m, (obj && *obj) ? &(*obj)->ro : NULL, "ro", errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->drv : NULL, "drv", errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_backing_file : NULL, "backing_file", errp);
if ((*obj)->has_backing_file) {
visit_type_str(m, (obj && *obj) ? &(*obj)->backing_file : NULL, "backing_file", errp);
}
visit_end_optional(m, errp);
visit_type_bool(m, (obj && *obj) ? &(*obj)->encrypted : NULL, "encrypted", errp);
visit_end_struct(m, errp);
}
static void get_string(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
char **ptr = qdev_get_prop_ptr(dev, prop);
if (!*ptr) {
char *str = (char *)"";
visit_type_str(v, name, &str, errp);
} else {
visit_type_str(v, name, ptr, errp);
}
}
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 void set_pointer(Object *obj, Visitor *v, Property *prop,
int (*parse)(DeviceState *dev, const char *str, void **ptr),
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Error *local_err = NULL;
void **ptr = qdev_get_prop_ptr(dev, prop);
char *str;
int ret;
if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED);
return;
}
visit_type_str(v, &str, name, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
if (!*str) {
g_free(str);
*ptr = NULL;
return;
}
ret = parse(dev, str, ptr);
error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
g_free(str);
}
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);
}
void input_type_enum(Visitor *v, int *obj, const char * const strings[],
const char *kind, const char *name,
Error **errp)
{
Error *local_err = NULL;
int64_t value = 0;
char *enum_str;
assert(strings);
visit_type_str(v, &enum_str, name, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
while (strings[value] != NULL) {
if (strcmp(strings[value], enum_str) == 0) {
break;
}
value++;
}
if (strings[value] == NULL) {
error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
g_free(enum_str);
return;
}
g_free(enum_str);
*obj = value;
}
static void set_generic(DeviceState *dev, Visitor *v, void *opaque,
const char *name, Error **errp)
{
Property *prop = opaque;
Error *local_err = NULL;
char *str;
int ret;
if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED);
return;
}
visit_type_str(v, &str, name, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
if (!*str) {
g_free(str);
error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
return;
}
ret = prop->info->parse(dev, prop, str);
error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
g_free(str);
}
static void set_string(DeviceState *dev, Visitor *v, void *opaque,
const char *name, Error **errp)
{
Property *prop = opaque;
char **ptr = qdev_get_prop_ptr(dev, prop);
Error *local_err = NULL;
char *str;
if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED);
return;
}
visit_type_str(v, &str, name, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
if (!*str) {
g_free(str);
str = NULL;
}
if (*ptr) {
g_free(*ptr);
}
*ptr = str;
}
static void set_tpm(Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp)
{
DeviceState *dev = DEVICE(obj);
Error *local_err = NULL;
Property *prop = opaque;
TPMBackend *s, **be = qdev_get_prop_ptr(dev, prop);
char *str;
if (dev->realized) {
qdev_prop_set_after_realize(dev, name, errp);
return;
}
visit_type_str(v, name, &str, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
s = qemu_find_tpm_be(str);
if (s == NULL) {
error_setg(errp, "Property '%s.%s' can't find value '%s'",
object_get_typename(obj), prop->name, str);
} else if (tpm_backend_init(s, TPM_IF(obj), errp) == 0) {
*be = s; /* weak reference, avoid cyclic ref */
}
g_free(str);
}
/*
* bus-local address, i.e. "$slot" or "$slot.$fn"
*/
static void set_pci_devfn(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
unsigned int slot, fn, n;
Error *local_err = NULL;
char *str = (char *)"";
if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED);
return;
}
visit_type_str(v, &str, name, &local_err);
if (local_err) {
return set_int32(obj, v, opaque, name, errp);
}
if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
fn = 0;
if (sscanf(str, "%x%n", &slot, &n) != 1) {
goto invalid;
}
}
if (str[n] != '\0' || fn > 7 || slot > 31) {
goto invalid;
}
*ptr = slot << 3 | fn;
return;
invalid:
error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
}
static void set_pointer(Object *obj, Visitor *v, Property *prop,
void (*parse)(DeviceState *dev, const char *str,
void **ptr, const char *propname,
Error **errp),
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Error *local_err = NULL;
void **ptr = qdev_get_prop_ptr(dev, prop);
char *str;
if (dev->realized) {
qdev_prop_set_after_realize(dev, name, errp);
return;
}
visit_type_str(v, name, &str, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
if (!*str) {
g_free(str);
*ptr = NULL;
return;
}
parse(dev, str, ptr, prop->name, errp);
g_free(str);
}
static void spapr_cap_set_string(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
sPAPRCapabilityInfo *cap = opaque;
sPAPRMachineState *spapr = SPAPR_MACHINE(obj);
Error *local_err = NULL;
uint8_t i;
char *val;
visit_type_str(v, name, &val, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
if (!strcmp(val, "?")) {
error_setg(errp, "%s", cap->possible->help);
goto out;
}
for (i = 0; i < cap->possible->num; i++) {
if (!strcasecmp(val, cap->possible->vals[i])) {
spapr->cmd_line_caps[cap->index] = true;
spapr->eff.caps[cap->index] = i;
goto out;
}
}
error_setg(errp, "Invalid capability mode \"%s\" for cap-%s", val,
cap->name);
out:
g_free(val);
}
static void visit_type_TestStruct(Visitor *v, TestStruct **obj,
const char *name, Error **errp)
{
Error *err = NULL;
visit_start_struct(v, (void **)obj, "TestStruct", name, sizeof(TestStruct),
&err);
if (err) {
goto out;
}
visit_type_int(v, &(*obj)->integer, "integer", &err);
if (err) {
goto out_end;
}
visit_type_bool(v, &(*obj)->boolean, "boolean", &err);
if (err) {
goto out_end;
}
visit_type_str(v, &(*obj)->string, "string", &err);
out_end:
error_propagate(errp, err);
err = NULL;
visit_end_struct(v, &err);
out:
error_propagate(errp, err);
}
static void visit_type_GuestNetworkInterface_fields(Visitor *m, GuestNetworkInterface ** obj, Error **errp)
{
Error *err = NULL;
visit_type_str(m, obj ? &(*obj)->name : NULL, "name", &err);
visit_start_optional(m, obj ? &(*obj)->has_hardware_address : NULL, "hardware-address", &err);
if (obj && (*obj)->has_hardware_address) {
visit_type_str(m, obj ? &(*obj)->hardware_address : NULL, "hardware-address", &err);
}
visit_end_optional(m, &err);
visit_start_optional(m, obj ? &(*obj)->has_ip_addresses : NULL, "ip-addresses", &err);
if (obj && (*obj)->has_ip_addresses) {
visit_type_GuestIpAddressList(m, obj ? &(*obj)->ip_addresses : NULL, "ip-addresses", &err);
}
visit_end_optional(m, &err);
error_propagate(errp, err);
}
static void visit_type_GuestAgentInfo_fields(Visitor *m, GuestAgentInfo ** obj, Error **errp)
{
Error *err = NULL;
visit_type_str(m, obj ? &(*obj)->version : NULL, "version", &err);
visit_type_GuestAgentCommandInfoList(m, obj ? &(*obj)->supported_commands : NULL, "supported_commands", &err);
error_propagate(errp, err);
}
static void visit_type_GuestAgentCommandInfo_fields(Visitor *m, GuestAgentCommandInfo ** obj, Error **errp)
{
Error *err = NULL;
visit_type_str(m, obj ? &(*obj)->name : NULL, "name", &err);
visit_type_bool(m, obj ? &(*obj)->enabled : NULL, "enabled", &err);
visit_type_bool(m, obj ? &(*obj)->success_response : NULL, "success-response", &err);
error_propagate(errp, err);
}
static void visit_type_GuestIpAddress_fields(Visitor *m, GuestIpAddress ** obj, Error **errp)
{
Error *err = NULL;
visit_type_str(m, obj ? &(*obj)->ip_address : NULL, "ip-address", &err);
visit_type_GuestIpAddressType(m, obj ? &(*obj)->ip_address_type : NULL, "ip-address-type", &err);
visit_type_int(m, obj ? &(*obj)->prefix : NULL, "prefix", &err);
error_propagate(errp, err);
}
void visit_type_VncClientInfo(Visitor *m, VncClientInfo ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "VncClientInfo", name, sizeof(VncClientInfo), errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->host : NULL, "host", errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->family : NULL, "family", errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->service : NULL, "service", errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_x509_dname : NULL, "x509_dname", errp);
if ((*obj)->has_x509_dname) {
visit_type_str(m, (obj && *obj) ? &(*obj)->x509_dname : NULL, "x509_dname", errp);
}
visit_end_optional(m, errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_sasl_username : NULL, "sasl_username", errp);
if ((*obj)->has_sasl_username) {
visit_type_str(m, (obj && *obj) ? &(*obj)->sasl_username : NULL, "sasl_username", errp);
}
visit_end_optional(m, errp);
visit_end_struct(m, errp);
}
void visit_type_MouseInfo(Visitor *m, MouseInfo ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "MouseInfo", name, sizeof(MouseInfo), errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->name : NULL, "name", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->index : NULL, "index", errp);
visit_type_bool(m, (obj && *obj) ? &(*obj)->current : NULL, "current", errp);
visit_type_bool(m, (obj && *obj) ? &(*obj)->absolute : NULL, "absolute", errp);
visit_end_struct(m, errp);
}
static void visit_type_GuestFileRead_fields(Visitor *m, GuestFileRead ** obj, Error **errp)
{
Error *err = NULL;
visit_type_int(m, obj ? &(*obj)->count : NULL, "count", &err);
visit_type_str(m, obj ? &(*obj)->buf_b64 : NULL, "buf-b64", &err);
visit_type_bool(m, obj ? &(*obj)->eof : NULL, "eof", &err);
error_propagate(errp, err);
}
void visit_type_NameInfo(Visitor *m, NameInfo ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "NameInfo", name, sizeof(NameInfo), errp);
visit_start_optional(m, (obj && *obj) ? &(*obj)->has_name : NULL, "name", errp);
if ((*obj)->has_name) {
visit_type_str(m, (obj && *obj) ? &(*obj)->name : NULL, "name", errp);
}
visit_end_optional(m, errp);
visit_end_struct(m, errp);
}
/* --- netdev device --- */
static void get_netdev(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);
char *p = g_strdup(peers_ptr->ncs[0] ? peers_ptr->ncs[0]->name : "");
visit_type_str(v, name, &p, errp);
g_free(p);
}
static void get_chr(Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp)
{
DeviceState *dev = DEVICE(obj);
CharBackend *be = qdev_get_prop_ptr(dev, opaque);
char *p;
p = g_strdup(be->chr && be->chr->label ? be->chr->label : "");
visit_type_str(v, name, &p, errp);
g_free(p);
}
void visit_type_VersionInfo(Visitor *m, VersionInfo ** obj, const char *name, Error **errp)
{
visit_start_struct(m, (void **)obj, "VersionInfo", name, sizeof(VersionInfo), errp);
visit_start_struct(m, NULL, "", "qemu", 0, errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->qemu.major : NULL, "major", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->qemu.minor : NULL, "minor", errp);
visit_type_int(m, (obj && *obj) ? &(*obj)->qemu.micro : NULL, "micro", errp);
visit_end_struct(m, errp);
visit_type_str(m, (obj && *obj) ? &(*obj)->package : NULL, "package", errp);
visit_end_struct(m, errp);
}
static void get_pointer(Object *obj, Visitor *v, Property *prop,
const char *(*print)(void *ptr),
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
void **ptr = qdev_get_prop_ptr(dev, prop);
char *p;
p = (char *) (*ptr ? print(*ptr) : "");
visit_type_str(v, &p, name, errp);
}
