1 #include "qemu/osdep.h"
4 #include "qapi/qmp/qerror.h"
5 #include "qemu/error-report.h"
6 #include "sysemu/block-backend.h"
7 #include "hw/block/block.h"
9 #include "qapi/visitor.h"
10 #include "sysemu/char.h"
12 void qdev_prop_set_after_realize(DeviceState
*dev
, const char *name
,
16 error_setg(errp
, "Attempt to set property '%s' on device '%s' "
17 "(type '%s') after it was realized", name
, dev
->id
,
18 object_get_typename(OBJECT(dev
)));
20 error_setg(errp
, "Attempt to set property '%s' on anonymous device "
21 "(type '%s') after it was realized", name
,
22 object_get_typename(OBJECT(dev
)));
26 void qdev_prop_allow_set_link_before_realize(Object
*obj
, const char *name
,
27 Object
*val
, Error
**errp
)
29 DeviceState
*dev
= DEVICE(obj
);
32 error_setg(errp
, "Attempt to set link property '%s' on device '%s' "
33 "(type '%s') after it was realized",
34 name
, dev
->id
, object_get_typename(obj
));
38 void *qdev_get_prop_ptr(DeviceState
*dev
, Property
*prop
)
45 static void get_enum(Object
*obj
, Visitor
*v
, void *opaque
,
46 const char *name
, Error
**errp
)
48 DeviceState
*dev
= DEVICE(obj
);
49 Property
*prop
= opaque
;
50 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
52 visit_type_enum(v
, ptr
, prop
->info
->enum_table
,
53 prop
->info
->name
, prop
->name
, errp
);
56 static void set_enum(Object
*obj
, Visitor
*v
, void *opaque
,
57 const char *name
, Error
**errp
)
59 DeviceState
*dev
= DEVICE(obj
);
60 Property
*prop
= opaque
;
61 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
64 qdev_prop_set_after_realize(dev
, name
, errp
);
68 visit_type_enum(v
, ptr
, prop
->info
->enum_table
,
69 prop
->info
->name
, prop
->name
, errp
);
74 static uint32_t qdev_get_prop_mask(Property
*prop
)
76 assert(prop
->info
== &qdev_prop_bit
);
77 return 0x1 << prop
->bitnr
;
80 static void bit_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
82 uint32_t *p
= qdev_get_prop_ptr(dev
, props
);
83 uint32_t mask
= qdev_get_prop_mask(props
);
91 static void prop_get_bit(Object
*obj
, Visitor
*v
, void *opaque
,
92 const char *name
, Error
**errp
)
94 DeviceState
*dev
= DEVICE(obj
);
95 Property
*prop
= opaque
;
96 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
97 bool value
= (*p
& qdev_get_prop_mask(prop
)) != 0;
99 visit_type_bool(v
, &value
, name
, errp
);
102 static void prop_set_bit(Object
*obj
, Visitor
*v
, void *opaque
,
103 const char *name
, Error
**errp
)
105 DeviceState
*dev
= DEVICE(obj
);
106 Property
*prop
= opaque
;
107 Error
*local_err
= NULL
;
111 qdev_prop_set_after_realize(dev
, name
, errp
);
115 visit_type_bool(v
, &value
, name
, &local_err
);
117 error_propagate(errp
, local_err
);
120 bit_prop_set(dev
, prop
, value
);
123 PropertyInfo qdev_prop_bit
= {
125 .description
= "on/off",
132 static uint64_t qdev_get_prop_mask64(Property
*prop
)
134 assert(prop
->info
== &qdev_prop_bit64
);
135 return 0x1ull
<< prop
->bitnr
;
138 static void bit64_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
140 uint64_t *p
= qdev_get_prop_ptr(dev
, props
);
141 uint64_t mask
= qdev_get_prop_mask64(props
);
149 static void prop_get_bit64(Object
*obj
, Visitor
*v
, void *opaque
,
150 const char *name
, Error
**errp
)
152 DeviceState
*dev
= DEVICE(obj
);
153 Property
*prop
= opaque
;
154 uint64_t *p
= qdev_get_prop_ptr(dev
, prop
);
155 bool value
= (*p
& qdev_get_prop_mask64(prop
)) != 0;
157 visit_type_bool(v
, &value
, name
, errp
);
160 static void prop_set_bit64(Object
*obj
, Visitor
*v
, void *opaque
,
161 const char *name
, Error
**errp
)
163 DeviceState
*dev
= DEVICE(obj
);
164 Property
*prop
= opaque
;
165 Error
*local_err
= NULL
;
169 qdev_prop_set_after_realize(dev
, name
, errp
);
173 visit_type_bool(v
, &value
, name
, &local_err
);
175 error_propagate(errp
, local_err
);
178 bit64_prop_set(dev
, prop
, value
);
181 PropertyInfo qdev_prop_bit64
= {
183 .description
= "on/off",
184 .get
= prop_get_bit64
,
185 .set
= prop_set_bit64
,
190 static void get_bool(Object
*obj
, Visitor
*v
, void *opaque
,
191 const char *name
, Error
**errp
)
193 DeviceState
*dev
= DEVICE(obj
);
194 Property
*prop
= opaque
;
195 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
197 visit_type_bool(v
, ptr
, name
, errp
);
200 static void set_bool(Object
*obj
, Visitor
*v
, void *opaque
,
201 const char *name
, Error
**errp
)
203 DeviceState
*dev
= DEVICE(obj
);
204 Property
*prop
= opaque
;
205 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
208 qdev_prop_set_after_realize(dev
, name
, errp
);
212 visit_type_bool(v
, ptr
, name
, errp
);
215 PropertyInfo qdev_prop_bool
= {
221 /* --- 8bit integer --- */
223 static void get_uint8(Object
*obj
, Visitor
*v
, void *opaque
,
224 const char *name
, Error
**errp
)
226 DeviceState
*dev
= DEVICE(obj
);
227 Property
*prop
= opaque
;
228 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
230 visit_type_uint8(v
, ptr
, name
, errp
);
233 static void set_uint8(Object
*obj
, Visitor
*v
, void *opaque
,
234 const char *name
, Error
**errp
)
236 DeviceState
*dev
= DEVICE(obj
);
237 Property
*prop
= opaque
;
238 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
241 qdev_prop_set_after_realize(dev
, name
, errp
);
245 visit_type_uint8(v
, ptr
, name
, errp
);
248 PropertyInfo qdev_prop_uint8
= {
254 /* --- 16bit integer --- */
256 static void get_uint16(Object
*obj
, Visitor
*v
, void *opaque
,
257 const char *name
, Error
**errp
)
259 DeviceState
*dev
= DEVICE(obj
);
260 Property
*prop
= opaque
;
261 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
263 visit_type_uint16(v
, ptr
, name
, errp
);
266 static void set_uint16(Object
*obj
, Visitor
*v
, void *opaque
,
267 const char *name
, Error
**errp
)
269 DeviceState
*dev
= DEVICE(obj
);
270 Property
*prop
= opaque
;
271 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
274 qdev_prop_set_after_realize(dev
, name
, errp
);
278 visit_type_uint16(v
, ptr
, name
, errp
);
281 PropertyInfo qdev_prop_uint16
= {
287 /* --- 32bit integer --- */
289 static void get_uint32(Object
*obj
, Visitor
*v
, void *opaque
,
290 const char *name
, Error
**errp
)
292 DeviceState
*dev
= DEVICE(obj
);
293 Property
*prop
= opaque
;
294 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
296 visit_type_uint32(v
, ptr
, name
, errp
);
299 static void set_uint32(Object
*obj
, Visitor
*v
, void *opaque
,
300 const char *name
, Error
**errp
)
302 DeviceState
*dev
= DEVICE(obj
);
303 Property
*prop
= opaque
;
304 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
307 qdev_prop_set_after_realize(dev
, name
, errp
);
311 visit_type_uint32(v
, ptr
, name
, errp
);
314 static void get_int32(Object
*obj
, Visitor
*v
, void *opaque
,
315 const char *name
, Error
**errp
)
317 DeviceState
*dev
= DEVICE(obj
);
318 Property
*prop
= opaque
;
319 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
321 visit_type_int32(v
, ptr
, name
, errp
);
324 static void set_int32(Object
*obj
, Visitor
*v
, void *opaque
,
325 const char *name
, Error
**errp
)
327 DeviceState
*dev
= DEVICE(obj
);
328 Property
*prop
= opaque
;
329 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
332 qdev_prop_set_after_realize(dev
, name
, errp
);
336 visit_type_int32(v
, ptr
, name
, errp
);
339 PropertyInfo qdev_prop_uint32
= {
345 PropertyInfo qdev_prop_int32
= {
351 /* --- 64bit integer --- */
353 static void get_uint64(Object
*obj
, Visitor
*v
, void *opaque
,
354 const char *name
, Error
**errp
)
356 DeviceState
*dev
= DEVICE(obj
);
357 Property
*prop
= opaque
;
358 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
360 visit_type_uint64(v
, ptr
, name
, errp
);
363 static void set_uint64(Object
*obj
, Visitor
*v
, void *opaque
,
364 const char *name
, Error
**errp
)
366 DeviceState
*dev
= DEVICE(obj
);
367 Property
*prop
= opaque
;
368 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
371 qdev_prop_set_after_realize(dev
, name
, errp
);
375 visit_type_uint64(v
, ptr
, name
, errp
);
378 PropertyInfo qdev_prop_uint64
= {
386 static void release_string(Object
*obj
, const char *name
, void *opaque
)
388 Property
*prop
= opaque
;
389 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj
), prop
));
392 static void get_string(Object
*obj
, Visitor
*v
, void *opaque
,
393 const char *name
, Error
**errp
)
395 DeviceState
*dev
= DEVICE(obj
);
396 Property
*prop
= opaque
;
397 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
400 char *str
= (char *)"";
401 visit_type_str(v
, &str
, name
, errp
);
403 visit_type_str(v
, ptr
, name
, errp
);
407 static void set_string(Object
*obj
, Visitor
*v
, void *opaque
,
408 const char *name
, Error
**errp
)
410 DeviceState
*dev
= DEVICE(obj
);
411 Property
*prop
= opaque
;
412 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
413 Error
*local_err
= NULL
;
417 qdev_prop_set_after_realize(dev
, name
, errp
);
421 visit_type_str(v
, &str
, name
, &local_err
);
423 error_propagate(errp
, local_err
);
430 PropertyInfo qdev_prop_string
= {
432 .release
= release_string
,
437 /* --- pointer --- */
439 /* Not a proper property, just for dirty hacks. TODO Remove it! */
440 PropertyInfo qdev_prop_ptr
= {
444 /* --- mac address --- */
447 * accepted syntax versions:
451 static void get_mac(Object
*obj
, Visitor
*v
, void *opaque
,
452 const char *name
, Error
**errp
)
454 DeviceState
*dev
= DEVICE(obj
);
455 Property
*prop
= opaque
;
456 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
457 char buffer
[2 * 6 + 5 + 1];
460 snprintf(buffer
, sizeof(buffer
), "%02x:%02x:%02x:%02x:%02x:%02x",
461 mac
->a
[0], mac
->a
[1], mac
->a
[2],
462 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
464 visit_type_str(v
, &p
, name
, errp
);
467 static void set_mac(Object
*obj
, Visitor
*v
, void *opaque
,
468 const char *name
, Error
**errp
)
470 DeviceState
*dev
= DEVICE(obj
);
471 Property
*prop
= opaque
;
472 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
473 Error
*local_err
= NULL
;
478 qdev_prop_set_after_realize(dev
, name
, errp
);
482 visit_type_str(v
, &str
, name
, &local_err
);
484 error_propagate(errp
, local_err
);
488 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
489 if (!qemu_isxdigit(str
[pos
])) {
492 if (!qemu_isxdigit(str
[pos
+1])) {
496 if (str
[pos
+2] != '\0') {
500 if (str
[pos
+2] != ':' && str
[pos
+2] != '-') {
504 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
510 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
514 PropertyInfo qdev_prop_macaddr
= {
516 .description
= "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
521 /* --- lost tick policy --- */
523 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy
) != sizeof(int));
525 PropertyInfo qdev_prop_losttickpolicy
= {
526 .name
= "LostTickPolicy",
527 .enum_table
= LostTickPolicy_lookup
,
532 /* --- BIOS CHS translation */
534 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation
) != sizeof(int));
536 PropertyInfo qdev_prop_bios_chs_trans
= {
537 .name
= "BiosAtaTranslation",
538 .description
= "Logical CHS translation algorithm, "
539 "auto/none/lba/large/rechs",
540 .enum_table
= BiosAtaTranslation_lookup
,
545 /* --- FDC default drive types */
547 PropertyInfo qdev_prop_fdc_drive_type
= {
548 .name
= "FdcDriveType",
549 .description
= "FDC drive type, "
550 "144/288/120/none/auto",
551 .enum_table
= FloppyDriveType_lookup
,
556 /* --- pci address --- */
559 * bus-local address, i.e. "$slot" or "$slot.$fn"
561 static void set_pci_devfn(Object
*obj
, Visitor
*v
, void *opaque
,
562 const char *name
, Error
**errp
)
564 DeviceState
*dev
= DEVICE(obj
);
565 Property
*prop
= opaque
;
566 int32_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
567 unsigned int slot
, fn
, n
;
568 Error
*local_err
= NULL
;
572 qdev_prop_set_after_realize(dev
, name
, errp
);
576 visit_type_str(v
, &str
, name
, &local_err
);
578 error_free(local_err
);
580 visit_type_int32(v
, &value
, name
, &local_err
);
582 error_propagate(errp
, local_err
);
583 } else if (value
< -1 || value
> 255) {
584 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
585 name
? name
: "null", "pci_devfn");
592 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
594 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
598 if (str
[n
] != '\0' || fn
> 7 || slot
> 31) {
601 *ptr
= slot
<< 3 | fn
;
606 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
610 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
,
613 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
616 return snprintf(dest
, len
, "<unset>");
618 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
622 PropertyInfo qdev_prop_pci_devfn
= {
624 .description
= "Slot and optional function number, example: 06.0 or 06",
625 .print
= print_pci_devfn
,
627 .set
= set_pci_devfn
,
630 /* --- blocksize --- */
632 static void set_blocksize(Object
*obj
, Visitor
*v
, void *opaque
,
633 const char *name
, Error
**errp
)
635 DeviceState
*dev
= DEVICE(obj
);
636 Property
*prop
= opaque
;
637 uint16_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
638 Error
*local_err
= NULL
;
639 const int64_t min
= 512;
640 const int64_t max
= 32768;
643 qdev_prop_set_after_realize(dev
, name
, errp
);
647 visit_type_uint16(v
, &value
, name
, &local_err
);
649 error_propagate(errp
, local_err
);
652 /* value of 0 means "unset" */
653 if (value
&& (value
< min
|| value
> max
)) {
654 error_setg(errp
, QERR_PROPERTY_VALUE_OUT_OF_RANGE
,
655 dev
->id
? : "", name
, (int64_t)value
, min
, max
);
659 /* We rely on power-of-2 blocksizes for bitmasks */
660 if ((value
& (value
- 1)) != 0) {
662 "Property %s.%s doesn't take value '%" PRId64
"', it's not a power of 2",
663 dev
->id
?: "", name
, (int64_t)value
);
670 PropertyInfo qdev_prop_blocksize
= {
672 .description
= "A power of two between 512 and 32768",
674 .set
= set_blocksize
,
677 /* --- pci host address --- */
679 static void get_pci_host_devaddr(Object
*obj
, Visitor
*v
, void *opaque
,
680 const char *name
, Error
**errp
)
682 DeviceState
*dev
= DEVICE(obj
);
683 Property
*prop
= opaque
;
684 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
685 char buffer
[] = "xxxx:xx:xx.x";
689 rc
= snprintf(buffer
, sizeof(buffer
), "%04x:%02x:%02x.%d",
690 addr
->domain
, addr
->bus
, addr
->slot
, addr
->function
);
691 assert(rc
== sizeof(buffer
) - 1);
693 visit_type_str(v
, &p
, name
, errp
);
697 * Parse [<domain>:]<bus>:<slot>.<func>
698 * if <domain> is not supplied, it's assumed to be 0.
700 static void set_pci_host_devaddr(Object
*obj
, Visitor
*v
, void *opaque
,
701 const char *name
, Error
**errp
)
703 DeviceState
*dev
= DEVICE(obj
);
704 Property
*prop
= opaque
;
705 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
706 Error
*local_err
= NULL
;
710 unsigned long dom
= 0, bus
= 0;
711 unsigned int slot
= 0, func
= 0;
714 qdev_prop_set_after_realize(dev
, name
, errp
);
718 visit_type_str(v
, &str
, name
, &local_err
);
720 error_propagate(errp
, local_err
);
725 val
= strtoul(p
, &e
, 16);
726 if (e
== p
|| *e
!= ':') {
732 val
= strtoul(p
, &e
, 16);
740 val
= strtoul(p
, &e
, 16);
751 val
= strtoul(p
, &e
, 10);
757 if (dom
> 0xffff || bus
> 0xff || slot
> 0x1f || func
> 7) {
768 addr
->function
= func
;
774 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
778 PropertyInfo qdev_prop_pci_host_devaddr
= {
780 .description
= "Address (bus/device/function) of "
781 "the host device, example: 04:10.0",
782 .get
= get_pci_host_devaddr
,
783 .set
= set_pci_host_devaddr
,
786 /* --- support for array properties --- */
788 /* Used as an opaque for the object properties we add for each
789 * array element. Note that the struct Property must be first
790 * in the struct so that a pointer to this works as the opaque
791 * for the underlying element's property hooks as well as for
792 * our own release callback.
795 struct Property prop
;
797 ObjectPropertyRelease
*release
;
798 } ArrayElementProperty
;
800 /* object property release callback for array element properties:
801 * we call the underlying element's property release hook, and
802 * then free the memory we allocated when we added the property.
804 static void array_element_release(Object
*obj
, const char *name
, void *opaque
)
806 ArrayElementProperty
*p
= opaque
;
808 p
->release(obj
, name
, opaque
);
814 static void set_prop_arraylen(Object
*obj
, Visitor
*v
, void *opaque
,
815 const char *name
, Error
**errp
)
817 /* Setter for the property which defines the length of a
818 * variable-sized property array. As well as actually setting the
819 * array-length field in the device struct, we have to create the
820 * array itself and dynamically add the corresponding properties.
822 DeviceState
*dev
= DEVICE(obj
);
823 Property
*prop
= opaque
;
824 uint32_t *alenptr
= qdev_get_prop_ptr(dev
, prop
);
825 void **arrayptr
= (void *)dev
+ prop
->arrayoffset
;
826 Error
*local_err
= NULL
;
828 const char *arrayname
;
832 qdev_prop_set_after_realize(dev
, name
, errp
);
836 error_setg(errp
, "array size property %s may not be set more than once",
840 visit_type_uint32(v
, alenptr
, name
, &local_err
);
842 error_propagate(errp
, local_err
);
849 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
850 * strip it off so we can get the name of the array itself.
852 assert(strncmp(name
, PROP_ARRAY_LEN_PREFIX
,
853 strlen(PROP_ARRAY_LEN_PREFIX
)) == 0);
854 arrayname
= name
+ strlen(PROP_ARRAY_LEN_PREFIX
);
856 /* Note that it is the responsibility of the individual device's deinit
857 * to free the array proper.
859 *arrayptr
= eltptr
= g_malloc0(*alenptr
* prop
->arrayfieldsize
);
860 for (i
= 0; i
< *alenptr
; i
++, eltptr
+= prop
->arrayfieldsize
) {
861 char *propname
= g_strdup_printf("%s[%d]", arrayname
, i
);
862 ArrayElementProperty
*arrayprop
= g_new0(ArrayElementProperty
, 1);
863 arrayprop
->release
= prop
->arrayinfo
->release
;
864 arrayprop
->propname
= propname
;
865 arrayprop
->prop
.info
= prop
->arrayinfo
;
866 arrayprop
->prop
.name
= propname
;
867 /* This ugly piece of pointer arithmetic sets up the offset so
868 * that when the underlying get/set hooks call qdev_get_prop_ptr
869 * they get the right answer despite the array element not actually
870 * being inside the device struct.
872 arrayprop
->prop
.offset
= eltptr
- (void *)dev
;
873 assert(qdev_get_prop_ptr(dev
, &arrayprop
->prop
) == eltptr
);
874 object_property_add(obj
, propname
,
875 arrayprop
->prop
.info
->name
,
876 arrayprop
->prop
.info
->get
,
877 arrayprop
->prop
.info
->set
,
878 array_element_release
,
879 arrayprop
, &local_err
);
881 error_propagate(errp
, local_err
);
887 PropertyInfo qdev_prop_arraylen
= {
890 .set
= set_prop_arraylen
,
893 /* --- public helpers --- */
895 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
900 while (props
->name
) {
901 if (strcmp(props
->name
, name
) == 0) {
909 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
914 /* device properties */
915 class = object_get_class(OBJECT(dev
));
917 prop
= qdev_prop_walk(DEVICE_CLASS(class)->props
, name
);
921 class = object_class_get_parent(class);
922 } while (class != object_class_by_name(TYPE_DEVICE
));
927 void error_set_from_qdev_prop_error(Error
**errp
, int ret
, DeviceState
*dev
,
928 Property
*prop
, const char *value
)
932 error_setg(errp
, "Property '%s.%s' can't take value '%s', it's in use",
933 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
937 error_setg(errp
, QERR_PROPERTY_VALUE_BAD
,
938 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
941 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
942 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
949 void qdev_prop_set_bit(DeviceState
*dev
, const char *name
, bool value
)
951 object_property_set_bool(OBJECT(dev
), value
, name
, &error_abort
);
954 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
956 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
959 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
961 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
964 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
966 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
969 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
971 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
974 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
976 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
979 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, const char *value
)
981 object_property_set_str(OBJECT(dev
), value
, name
, &error_abort
);
984 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
, uint8_t *value
)
986 char str
[2 * 6 + 5 + 1];
987 snprintf(str
, sizeof(str
), "%02x:%02x:%02x:%02x:%02x:%02x",
988 value
[0], value
[1], value
[2], value
[3], value
[4], value
[5]);
990 object_property_set_str(OBJECT(dev
), str
, name
, &error_abort
);
993 void qdev_prop_set_enum(DeviceState
*dev
, const char *name
, int value
)
997 prop
= qdev_prop_find(dev
, name
);
998 object_property_set_str(OBJECT(dev
), prop
->info
->enum_table
[value
],
1002 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
1007 prop
= qdev_prop_find(dev
, name
);
1008 assert(prop
&& prop
->info
== &qdev_prop_ptr
);
1009 ptr
= qdev_get_prop_ptr(dev
, prop
);
1013 static QTAILQ_HEAD(, GlobalProperty
) global_props
=
1014 QTAILQ_HEAD_INITIALIZER(global_props
);
1016 void qdev_prop_register_global(GlobalProperty
*prop
)
1018 QTAILQ_INSERT_TAIL(&global_props
, prop
, next
);
1021 void qdev_prop_register_global_list(GlobalProperty
*props
)
1025 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
1026 qdev_prop_register_global(props
+i
);
1030 int qdev_prop_check_globals(void)
1032 GlobalProperty
*prop
;
1035 QTAILQ_FOREACH(prop
, &global_props
, next
) {
1041 if (!prop
->user_provided
) {
1044 oc
= object_class_by_name(prop
->driver
);
1045 oc
= object_class_dynamic_cast(oc
, TYPE_DEVICE
);
1047 error_report("Warning: global %s.%s has invalid class name",
1048 prop
->driver
, prop
->property
);
1052 dc
= DEVICE_CLASS(oc
);
1053 if (!dc
->hotpluggable
&& !prop
->used
) {
1054 error_report("Warning: global %s.%s=%s not used",
1055 prop
->driver
, prop
->property
, prop
->value
);
1063 static void qdev_prop_set_globals_for_type(DeviceState
*dev
,
1064 const char *typename
)
1066 GlobalProperty
*prop
;
1068 QTAILQ_FOREACH(prop
, &global_props
, next
) {
1071 if (strcmp(typename
, prop
->driver
) != 0) {
1075 object_property_parse(OBJECT(dev
), prop
->value
, prop
->property
, &err
);
1077 assert(prop
->user_provided
);
1078 error_reportf_err(err
, "Warning: global %s.%s=%s ignored: ",
1079 prop
->driver
, prop
->property
, prop
->value
);
1085 void qdev_prop_set_globals(DeviceState
*dev
)
1087 ObjectClass
*class = object_get_class(OBJECT(dev
));
1090 qdev_prop_set_globals_for_type(dev
, object_class_get_name(class));
1091 class = object_class_get_parent(class);
1095 /* --- 64bit unsigned int 'size' type --- */
1097 static void get_size(Object
*obj
, Visitor
*v
, void *opaque
,
1098 const char *name
, Error
**errp
)
1100 DeviceState
*dev
= DEVICE(obj
);
1101 Property
*prop
= opaque
;
1102 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
1104 visit_type_size(v
, ptr
, name
, errp
);
1107 static void set_size(Object
*obj
, Visitor
*v
, void *opaque
,
1108 const char *name
, Error
**errp
)
1110 DeviceState
*dev
= DEVICE(obj
);
1111 Property
*prop
= opaque
;
1112 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
1114 visit_type_size(v
, ptr
, name
, errp
);
1117 PropertyInfo qdev_prop_size
= {