falso
/
qemu-irix
mirror of https://github.com/n64decomp/qemu-irix.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

qdev: Switch property accessors to fixed-width visitor interfaces 

This introduces {get,set}_uint{8,16,32,64}() functions for the
respective qdev types.
TADDR and VLAN are switched to explicit int64, BLOCKSIZE to uint16.

Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
This commit is contained in:
Michael Roth 2012-02-22 12:26:37 -06:00 committed by Andreas Färber
parent 09f1bbcd83
commit c08fb2ac00
2 changed files with 91 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hw/qdev-addr.c
View File

@ -27,7 +27,7 @@ static void get_taddr(Object *obj, Visitor *v, void *opaque,
int64_t value; int64_t value;
value = *ptr; value = *ptr;
visit_type_int(v, &value, name, errp); visit_type_int64(v, &value, name, errp);
} }
static void set_taddr(Object *obj, Visitor *v, void *opaque, static void set_taddr(Object *obj, Visitor *v, void *opaque,
@ -44,7 +44,7 @@ static void set_taddr(Object *obj, Visitor *v, void *opaque,
return; return;
} }
visit_type_int(v, &value, name, &local_err); visit_type_int64(v, &value, name, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;

150
hw/qdev-properties.c
View File

@ -76,33 +76,30 @@ PropertyInfo qdev_prop_bit = {
/* --- 8bit integer --- */ /* --- 8bit integer --- */
static void get_int8(Object *obj, Visitor *v, void *opaque, static void get_uint8(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int8_t *ptr = qdev_get_prop_ptr(dev, prop); uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
int64_t value;
value = *ptr; visit_type_uint8(v, ptr, name, errp);
visit_type_int(v, &value, name, errp);
} }
static void set_int8(Object *obj, Visitor *v, void *opaque, static void set_uint8(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int8_t *ptr = qdev_get_prop_ptr(dev, prop); uint8_t value, *ptr = qdev_get_prop_ptr(dev, prop);
Error *local_err = NULL; Error *local_err = NULL;
int64_t value;
if (dev->state != DEV_STATE_CREATED) { if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED); error_set(errp, QERR_PERMISSION_DENIED);
return; return;
} }
visit_type_int(v, &value, name, &local_err); visit_type_uint8(v, &value, name, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;
@ -111,15 +108,15 @@ static void set_int8(Object *obj, Visitor *v, void *opaque,
*ptr = value; *ptr = value;
} else { } else {
error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
dev->id?:"", name, value, prop->info->min, dev->id?:"", name, (int64_t)value, prop->info->min,
prop->info->max); prop->info->max);
} }
} }
PropertyInfo qdev_prop_uint8 = { PropertyInfo qdev_prop_uint8 = {
.name = "uint8", .name = "uint8",
.get = get_int8, .get = get_uint8,
.set = set_int8, .set = set_uint8,
.min = 0, .min = 0,
.max = 255, .max = 255,
}; };
@ -154,41 +151,38 @@ PropertyInfo qdev_prop_hex8 = {
.legacy_name = "hex8", .legacy_name = "hex8",
.parse = parse_hex8, .parse = parse_hex8,
.print = print_hex8, .print = print_hex8,
.get = get_int8, .get = get_uint8,
.set = set_int8, .set = set_uint8,
.min = 0, .min = 0,
.max = 255, .max = 255,
}; };
/* --- 16bit integer --- */ /* --- 16bit integer --- */
static void get_int16(Object *obj, Visitor *v, void *opaque, static void get_uint16(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int16_t *ptr = qdev_get_prop_ptr(dev, prop); uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
int64_t value;
value = *ptr; visit_type_uint16(v, ptr, name, errp);
visit_type_int(v, &value, name, errp);
} }
static void set_int16(Object *obj, Visitor *v, void *opaque, static void set_uint16(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int16_t *ptr = qdev_get_prop_ptr(dev, prop); uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop);
Error *local_err = NULL; Error *local_err = NULL;
int64_t value;
if (dev->state != DEV_STATE_CREATED) { if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED); error_set(errp, QERR_PERMISSION_DENIED);
return; return;
} }
visit_type_int(v, &value, name, &local_err); visit_type_uint16(v, &value, name, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;
@ -197,31 +191,67 @@ static void set_int16(Object *obj, Visitor *v, void *opaque,
*ptr = value; *ptr = value;
} else { } else {
error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
dev->id?:"", name, value, prop->info->min, dev->id?:"", name, (int64_t)value, prop->info->min,
prop->info->max); prop->info->max);
} }
} }
PropertyInfo qdev_prop_uint16 = { PropertyInfo qdev_prop_uint16 = {
.name = "uint16", .name = "uint16",
.get = get_int16, .get = get_uint16,
.set = set_int16, .set = set_uint16,
.min = 0, .min = 0,
.max = 65535, .max = 65535,
}; };
/* --- 32bit integer --- */ /* --- 32bit integer --- */
static void get_uint32(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
uint32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
value = *ptr;
visit_type_uint32(v, &value, name, errp);
}
static void set_uint32(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
uint32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
Error *local_err = NULL;
if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED);
return;
}
visit_type_uint32(v, &value, name, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
if (value >= prop->info->min && value <= prop->info->max) {
*ptr = value;
} else {
error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
dev->id?:"", name, (int64_t)value, prop->info->min,
prop->info->max);
}
}
static void get_int32(Object *obj, Visitor *v, void *opaque, static void get_int32(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int32_t *ptr = qdev_get_prop_ptr(dev, prop); int32_t *ptr = qdev_get_prop_ptr(dev, prop);
int64_t value;
value = *ptr; visit_type_int32(v, ptr, name, errp);
visit_type_int(v, &value, name, errp);
} }
static void set_int32(Object *obj, Visitor *v, void *opaque, static void set_int32(Object *obj, Visitor *v, void *opaque,
@ -229,16 +259,15 @@ static void set_int32(Object *obj, Visitor *v, void *opaque,
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int32_t *ptr = qdev_get_prop_ptr(dev, prop); int32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
Error *local_err = NULL; Error *local_err = NULL;
int64_t value;
if (dev->state != DEV_STATE_CREATED) { if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED); error_set(errp, QERR_PERMISSION_DENIED);
return; return;
} }
visit_type_int(v, &value, name, &local_err); visit_type_int32(v, &value, name, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;
@ -247,15 +276,15 @@ static void set_int32(Object *obj, Visitor *v, void *opaque,
*ptr = value; *ptr = value;
} else { } else {
error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
dev->id?:"", name, value, prop->info->min, dev->id?:"", name, (int64_t)value, prop->info->min,
prop->info->max); prop->info->max);
} }
} }
PropertyInfo qdev_prop_uint32 = { PropertyInfo qdev_prop_uint32 = {
.name = "uint32", .name = "uint32",
.get = get_int32, .get = get_uint32,
.set = set_int32, .set = set_uint32,
.min = 0, .min = 0,
.max = 0xFFFFFFFFULL, .max = 0xFFFFFFFFULL,
}; };
@ -298,43 +327,43 @@ PropertyInfo qdev_prop_hex32 = {
.legacy_name = "hex32", .legacy_name = "hex32",
.parse = parse_hex32, .parse = parse_hex32,
.print = print_hex32, .print = print_hex32,
.get = get_int32, .get = get_uint32,
.set = set_int32, .set = set_uint32,
.min = 0, .min = 0,
.max = 0xFFFFFFFFULL, .max = 0xFFFFFFFFULL,
}; };
/* --- 64bit integer --- */ /* --- 64bit integer --- */
static void get_int64(Object *obj, Visitor *v, void *opaque, static void get_uint64(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int64_t *ptr = qdev_get_prop_ptr(dev, prop); uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
visit_type_int(v, ptr, name, errp); visit_type_uint64(v, ptr, name, errp);
} }
static void set_int64(Object *obj, Visitor *v, void *opaque, static void set_uint64(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp) const char *name, Error **errp)
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int64_t *ptr = qdev_get_prop_ptr(dev, prop); uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
if (dev->state != DEV_STATE_CREATED) { if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED); error_set(errp, QERR_PERMISSION_DENIED);
return; return;
} }
visit_type_int(v, ptr, name, errp); visit_type_uint64(v, ptr, name, errp);
} }
PropertyInfo qdev_prop_uint64 = { PropertyInfo qdev_prop_uint64 = {
.name = "uint64", .name = "uint64",
.get = get_int64, .get = get_uint64,
.set = set_int64, .set = set_uint64,
}; };
/* --- 64bit hex value --- */ /* --- 64bit hex value --- */
@ -367,8 +396,8 @@ PropertyInfo qdev_prop_hex64 = {
.legacy_name = "hex64", .legacy_name = "hex64",
.parse = parse_hex64, .parse = parse_hex64,
.print = print_hex64, .print = print_hex64,
.get = get_int64, .get = get_uint64,
.set = set_int64, .set = set_uint64,
}; };
/* --- string --- */ /* --- string --- */
@ -645,7 +674,7 @@ static void get_vlan(Object *obj, Visitor *v, void *opaque,
int64_t id; int64_t id;
id = *ptr ? (*ptr)->id : -1; id = *ptr ? (*ptr)->id : -1;
visit_type_int(v, &id, name, errp); visit_type_int64(v, &id, name, errp);
} }
static void set_vlan(Object *obj, Visitor *v, void *opaque, static void set_vlan(Object *obj, Visitor *v, void *opaque,
@ -663,7 +692,7 @@ static void set_vlan(Object *obj, Visitor *v, void *opaque,
return; return;
} }
visit_type_int(v, &id, name, &local_err); visit_type_int64(v, &id, name, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;
@ -886,23 +915,22 @@ static void set_blocksize(Object *obj, Visitor *v, void *opaque,
{ {
DeviceState *dev = DEVICE(obj); DeviceState *dev = DEVICE(obj);
Property *prop = opaque; Property *prop = opaque;
int16_t *ptr = qdev_get_prop_ptr(dev, prop); uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop);
Error *local_err = NULL; Error *local_err = NULL;
int64_t value;
if (dev->state != DEV_STATE_CREATED) { if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED); error_set(errp, QERR_PERMISSION_DENIED);
return; return;
} }
visit_type_int(v, &value, name, &local_err); visit_type_uint16(v, &value, name, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;
} }
if (value < prop->info->min || value > prop->info->max) { if (value < prop->info->min || value > prop->info->max) {
error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
dev->id?:"", name, value, prop->info->min, dev->id?:"", name, (int64_t)value, prop->info->min,
prop->info->max); prop->info->max);
return; return;
} }
@ -910,7 +938,7 @@ static void set_blocksize(Object *obj, Visitor *v, void *opaque,
/* We rely on power-of-2 blocksizes for bitmasks */ /* We rely on power-of-2 blocksizes for bitmasks */
if ((value & (value - 1)) != 0) { if ((value & (value - 1)) != 0) {
error_set(errp, QERR_PROPERTY_VALUE_NOT_POWER_OF_2, error_set(errp, QERR_PROPERTY_VALUE_NOT_POWER_OF_2,
dev->id?:"", name, value); dev->id?:"", name, (int64_t)value);
return; return;
} }
@ -919,7 +947,7 @@ static void set_blocksize(Object *obj, Visitor *v, void *opaque,
PropertyInfo qdev_prop_blocksize = { PropertyInfo qdev_prop_blocksize = {
.name = "blocksize", .name = "blocksize",
.get = get_int16, .get = get_uint16,
.set = set_blocksize, .set = set_blocksize,
.min = 512, .min = 512,
.max = 65024, .max = 65024,