proxmox-mirrors/qemu
1
0
Fork 0
mirror of https://git.proxmox.com/git/qemu synced 2025-08-14 10:31:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

qdev: remove parse/print methods for pointer properties

Browse Source 
Pointer properties (except for PROP_PTR of course) should not need a
legacy counterpart.  In the future, relative paths will ensure that
QEMU will support the same syntax as now for drives etc..

Reviewed-by: Anthony Liguori <aliguori@us.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Paolo Bonzini 2012-02-02 13:01:40 +01:00
parent b403298adb
commit 7b009e5d09
1 changed files with 79 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
hw/qdev-properties.c
View File

@ -579,9 +579,8 @@ PropertyInfo qdev_prop_string = {
/* --- drive --- */ /* --- drive --- */
static int parse_drive(DeviceState *dev, Property *prop, const char *str) static int parse_drive(DeviceState *dev, const char *str, void **ptr)
{ {
BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop);
BlockDriverState *bs; BlockDriverState *bs;
bs = bdrv_find(str); bs = bdrv_find(str);
@ -603,35 +602,30 @@ static void free_drive(DeviceState *dev, Property *prop)
} }
} }
static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len) static const char *print_drive(void *ptr)
{ {
BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop); return bdrv_get_device_name(ptr);
return snprintf(dest, len, "%s",
*ptr ? bdrv_get_device_name(*ptr) : "<null>");
} }
static void get_generic(Object *obj, Visitor *v, void *opaque, static void get_pointer(Object *obj, Visitor *v, Property *prop,
const char *(*print)(void *ptr),
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
void **ptr = qdev_get_prop_ptr(dev, prop); void **ptr = qdev_get_prop_ptr(dev, prop);
char buffer[1024]; char *p;
char *p = buffer;
buffer[0] = 0; p = (char *) (*ptr ? print(*ptr) : "");
if (*ptr) {
prop->info->print(dev, prop, buffer, sizeof(buffer));
}
visit_type_str(v, &p, name, errp); visit_type_str(v, &p, name, errp);
} }
static void set_generic(Object *obj, Visitor *v, void *opaque, static void set_pointer(Object *obj, Visitor *v, Property *prop,
int (*parse)(DeviceState *dev, const char *str, void **ptr),
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
Error *local_err = NULL; Error *local_err = NULL;
void **ptr = qdev_get_prop_ptr(dev, prop);
char *str; char *str;
int ret; int ret;
@ -650,36 +644,45 @@ static void set_generic(Object *obj, Visitor *v, void *opaque,
error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
return; return;
} }
ret = prop->info->parse(dev, prop, str); ret = parse(dev, str, ptr);
error_set_from_qdev_prop_error(errp, ret, dev, prop, str); error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
g_free(str); g_free(str);
} }
static void get_drive(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
get_pointer(obj, v, opaque, print_drive, name, errp);
}
static void set_drive(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
set_pointer(obj, v, opaque, parse_drive, name, errp);
}
PropertyInfo qdev_prop_drive = { PropertyInfo qdev_prop_drive = {
.name = "drive", .name = "drive",
.type = PROP_TYPE_DRIVE, .type = PROP_TYPE_DRIVE,
.size = sizeof(BlockDriverState *), .size = sizeof(BlockDriverState *),
.parse = parse_drive, .get = get_drive,
.print = print_drive, .set = set_drive,
.get = get_generic,
.set = set_generic,
.free = free_drive, .free = free_drive,
}; };
/* --- character device --- */ /* --- character device --- */
static int parse_chr(DeviceState *dev, Property *prop, const char *str) static int parse_chr(DeviceState *dev, const char *str, void **ptr)
{ {
CharDriverState **ptr = qdev_get_prop_ptr(dev, prop); CharDriverState *chr = qemu_chr_find(str);
if (chr == NULL) {
*ptr = qemu_chr_find(str);
if (*ptr == NULL) {
return -ENOENT; return -ENOENT;
} }
if ((*ptr)->avail_connections < 1) { if (chr->avail_connections < 1) {
return -EEXIST; return -EEXIST;
} }
--(*ptr)->avail_connections; *ptr = chr;
--chr->avail_connections;
return 0; return 0;
} }
@ -693,62 +696,75 @@ static void free_chr(DeviceState *dev, Property *prop)
} }
static int print_chr(DeviceState *dev, Property *prop, char *dest, size_t len) static const char *print_chr(void *ptr)
{ {
CharDriverState **ptr = qdev_get_prop_ptr(dev, prop); CharDriverState *chr = ptr;
if (*ptr && (*ptr)->label) { return chr->label ? chr->label : "";
return snprintf(dest, len, "%s", (*ptr)->label); }
} else {
return snprintf(dest, len, "<null>"); static void get_chr(Object *obj, Visitor *v, void *opaque,
} const char *name, Error **errp)
{
get_pointer(obj, v, opaque, print_chr, name, errp);
}
static void set_chr(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
set_pointer(obj, v, opaque, parse_chr, name, errp);
} }
PropertyInfo qdev_prop_chr = { PropertyInfo qdev_prop_chr = {
.name = "chr", .name = "chr",
.type = PROP_TYPE_CHR, .type = PROP_TYPE_CHR,
.size = sizeof(CharDriverState*), .size = sizeof(CharDriverState*),
.parse = parse_chr, .get = get_chr,
.print = print_chr, .set = set_chr,
.get = get_generic,
.set = set_generic,
.free = free_chr, .free = free_chr,
}; };
/* --- netdev device --- */ /* --- netdev device --- */
static int parse_netdev(DeviceState *dev, Property *prop, const char *str) static int parse_netdev(DeviceState *dev, const char *str, void **ptr)
{ {
VLANClientState **ptr = qdev_get_prop_ptr(dev, prop); VLANClientState *netdev = qemu_find_netdev(str);
*ptr = qemu_find_netdev(str); if (netdev == NULL) {
if (*ptr == NULL)
return -ENOENT; return -ENOENT;
if ((*ptr)->peer) { }
if (netdev->peer) {
return -EEXIST; return -EEXIST;
} }
*ptr = netdev;
return 0; return 0;
} }
static int print_netdev(DeviceState *dev, Property *prop, char *dest, size_t len) static const char *print_netdev(void *ptr)
{ {
VLANClientState **ptr = qdev_get_prop_ptr(dev, prop); VLANClientState *netdev = ptr;
if (*ptr && (*ptr)->name) { return netdev->name ? netdev->name : "";
return snprintf(dest, len, "%s", (*ptr)->name); }
} else {
return snprintf(dest, len, "<null>"); static void get_netdev(Object *obj, Visitor *v, void *opaque,
} const char *name, Error **errp)
{
get_pointer(obj, v, opaque, print_netdev, name, errp);
}
static void set_netdev(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
set_pointer(obj, v, opaque, parse_netdev, name, errp);
} }
PropertyInfo qdev_prop_netdev = { PropertyInfo qdev_prop_netdev = {
.name = "netdev", .name = "netdev",
.type = PROP_TYPE_NETDEV, .type = PROP_TYPE_NETDEV,
.size = sizeof(VLANClientState*), .size = sizeof(VLANClientState*),
.parse = parse_netdev, .get = get_netdev,
.print = print_netdev, .set = set_netdev,
.get = get_generic,
.set = set_generic,
}; };
/* --- vlan --- */ /* --- vlan --- */