1 #include "qemu/osdep.h"
4 #include "qapi/error.h"
5 #include "hw/pci/pci.h"
6 #include "qapi/qmp/qerror.h"
7 #include "qemu/error-report.h"
8 #include "sysemu/block-backend.h"
9 #include "hw/block/block.h"
11 #include "qapi/visitor.h"
12 #include "chardev/char.h"
14 void qdev_prop_set_after_realize(DeviceState
*dev
, const char *name
,
18 error_setg(errp
, "Attempt to set property '%s' on device '%s' "
19 "(type '%s') after it was realized", name
, dev
->id
,
20 object_get_typename(OBJECT(dev
)));
22 error_setg(errp
, "Attempt to set property '%s' on anonymous device "
23 "(type '%s') after it was realized", name
,
24 object_get_typename(OBJECT(dev
)));
28 void qdev_prop_allow_set_link_before_realize(Object
*obj
, const char *name
,
29 Object
*val
, Error
**errp
)
31 DeviceState
*dev
= DEVICE(obj
);
34 error_setg(errp
, "Attempt to set link property '%s' on device '%s' "
35 "(type '%s') after it was realized",
36 name
, dev
->id
, object_get_typename(obj
));
40 void *qdev_get_prop_ptr(DeviceState
*dev
, Property
*prop
)
47 static void get_enum(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
50 DeviceState
*dev
= DEVICE(obj
);
51 Property
*prop
= opaque
;
52 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
54 visit_type_enum(v
, prop
->name
, ptr
, prop
->info
->enum_table
, errp
);
57 static void set_enum(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
60 DeviceState
*dev
= DEVICE(obj
);
61 Property
*prop
= opaque
;
62 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
65 qdev_prop_set_after_realize(dev
, name
, errp
);
69 visit_type_enum(v
, prop
->name
, ptr
, prop
->info
->enum_table
, errp
);
72 static void set_default_value_enum(Object
*obj
, const Property
*prop
)
74 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
.i
],
75 prop
->name
, &error_abort
);
80 static uint32_t qdev_get_prop_mask(Property
*prop
)
82 assert(prop
->info
== &qdev_prop_bit
);
83 return 0x1 << prop
->bitnr
;
86 static void bit_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
88 uint32_t *p
= qdev_get_prop_ptr(dev
, props
);
89 uint32_t mask
= qdev_get_prop_mask(props
);
97 static void prop_get_bit(Object
*obj
, Visitor
*v
, const char *name
,
98 void *opaque
, Error
**errp
)
100 DeviceState
*dev
= DEVICE(obj
);
101 Property
*prop
= opaque
;
102 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
103 bool value
= (*p
& qdev_get_prop_mask(prop
)) != 0;
105 visit_type_bool(v
, name
, &value
, errp
);
108 static void prop_set_bit(Object
*obj
, Visitor
*v
, const char *name
,
109 void *opaque
, Error
**errp
)
111 DeviceState
*dev
= DEVICE(obj
);
112 Property
*prop
= opaque
;
113 Error
*local_err
= NULL
;
117 qdev_prop_set_after_realize(dev
, name
, errp
);
121 visit_type_bool(v
, name
, &value
, &local_err
);
123 error_propagate(errp
, local_err
);
126 bit_prop_set(dev
, prop
, value
);
129 static void set_default_value_bool(Object
*obj
, const Property
*prop
)
131 object_property_set_bool(obj
, prop
->defval
.u
, prop
->name
, &error_abort
);
134 PropertyInfo qdev_prop_bit
= {
136 .description
= "on/off",
139 .set_default_value
= set_default_value_bool
,
144 static uint64_t qdev_get_prop_mask64(Property
*prop
)
146 assert(prop
->info
== &qdev_prop_bit64
);
147 return 0x1ull
<< prop
->bitnr
;
150 static void bit64_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
152 uint64_t *p
= qdev_get_prop_ptr(dev
, props
);
153 uint64_t mask
= qdev_get_prop_mask64(props
);
161 static void prop_get_bit64(Object
*obj
, Visitor
*v
, const char *name
,
162 void *opaque
, Error
**errp
)
164 DeviceState
*dev
= DEVICE(obj
);
165 Property
*prop
= opaque
;
166 uint64_t *p
= qdev_get_prop_ptr(dev
, prop
);
167 bool value
= (*p
& qdev_get_prop_mask64(prop
)) != 0;
169 visit_type_bool(v
, name
, &value
, errp
);
172 static void prop_set_bit64(Object
*obj
, Visitor
*v
, const char *name
,
173 void *opaque
, Error
**errp
)
175 DeviceState
*dev
= DEVICE(obj
);
176 Property
*prop
= opaque
;
177 Error
*local_err
= NULL
;
181 qdev_prop_set_after_realize(dev
, name
, errp
);
185 visit_type_bool(v
, name
, &value
, &local_err
);
187 error_propagate(errp
, local_err
);
190 bit64_prop_set(dev
, prop
, value
);
193 PropertyInfo qdev_prop_bit64
= {
195 .description
= "on/off",
196 .get
= prop_get_bit64
,
197 .set
= prop_set_bit64
,
198 .set_default_value
= set_default_value_bool
,
203 static void get_bool(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
206 DeviceState
*dev
= DEVICE(obj
);
207 Property
*prop
= opaque
;
208 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
210 visit_type_bool(v
, name
, ptr
, errp
);
213 static void set_bool(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
216 DeviceState
*dev
= DEVICE(obj
);
217 Property
*prop
= opaque
;
218 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
221 qdev_prop_set_after_realize(dev
, name
, errp
);
225 visit_type_bool(v
, name
, ptr
, errp
);
228 PropertyInfo qdev_prop_bool
= {
232 .set_default_value
= set_default_value_bool
,
235 /* --- 8bit integer --- */
237 static void get_uint8(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
240 DeviceState
*dev
= DEVICE(obj
);
241 Property
*prop
= opaque
;
242 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
244 visit_type_uint8(v
, name
, ptr
, errp
);
247 static void set_uint8(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
250 DeviceState
*dev
= DEVICE(obj
);
251 Property
*prop
= opaque
;
252 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
255 qdev_prop_set_after_realize(dev
, name
, errp
);
259 visit_type_uint8(v
, name
, ptr
, errp
);
262 static void set_default_value_int(Object
*obj
, const Property
*prop
)
264 object_property_set_int(obj
, prop
->defval
.i
, prop
->name
, &error_abort
);
267 static void set_default_value_uint(Object
*obj
, const Property
*prop
)
269 object_property_set_uint(obj
, prop
->defval
.u
, prop
->name
, &error_abort
);
272 PropertyInfo qdev_prop_uint8
= {
276 .set_default_value
= set_default_value_uint
,
279 /* --- 16bit integer --- */
281 static void get_uint16(Object
*obj
, Visitor
*v
, const char *name
,
282 void *opaque
, Error
**errp
)
284 DeviceState
*dev
= DEVICE(obj
);
285 Property
*prop
= opaque
;
286 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
288 visit_type_uint16(v
, name
, ptr
, errp
);
291 static void set_uint16(Object
*obj
, Visitor
*v
, const char *name
,
292 void *opaque
, Error
**errp
)
294 DeviceState
*dev
= DEVICE(obj
);
295 Property
*prop
= opaque
;
296 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
299 qdev_prop_set_after_realize(dev
, name
, errp
);
303 visit_type_uint16(v
, name
, ptr
, errp
);
306 PropertyInfo qdev_prop_uint16
= {
310 .set_default_value
= set_default_value_uint
,
313 /* --- 32bit integer --- */
315 static void get_uint32(Object
*obj
, Visitor
*v
, const char *name
,
316 void *opaque
, Error
**errp
)
318 DeviceState
*dev
= DEVICE(obj
);
319 Property
*prop
= opaque
;
320 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
322 visit_type_uint32(v
, name
, ptr
, errp
);
325 static void set_uint32(Object
*obj
, Visitor
*v
, const char *name
,
326 void *opaque
, Error
**errp
)
328 DeviceState
*dev
= DEVICE(obj
);
329 Property
*prop
= opaque
;
330 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
333 qdev_prop_set_after_realize(dev
, name
, errp
);
337 visit_type_uint32(v
, name
, ptr
, errp
);
340 static void get_int32(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
343 DeviceState
*dev
= DEVICE(obj
);
344 Property
*prop
= opaque
;
345 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
347 visit_type_int32(v
, name
, ptr
, errp
);
350 static void set_int32(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
353 DeviceState
*dev
= DEVICE(obj
);
354 Property
*prop
= opaque
;
355 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
358 qdev_prop_set_after_realize(dev
, name
, errp
);
362 visit_type_int32(v
, name
, ptr
, errp
);
365 PropertyInfo qdev_prop_uint32
= {
369 .set_default_value
= set_default_value_uint
,
372 PropertyInfo qdev_prop_int32
= {
376 .set_default_value
= set_default_value_int
,
379 /* --- 64bit integer --- */
381 static void get_uint64(Object
*obj
, Visitor
*v
, const char *name
,
382 void *opaque
, Error
**errp
)
384 DeviceState
*dev
= DEVICE(obj
);
385 Property
*prop
= opaque
;
386 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
388 visit_type_uint64(v
, name
, ptr
, errp
);
391 static void set_uint64(Object
*obj
, Visitor
*v
, const char *name
,
392 void *opaque
, Error
**errp
)
394 DeviceState
*dev
= DEVICE(obj
);
395 Property
*prop
= opaque
;
396 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
399 qdev_prop_set_after_realize(dev
, name
, errp
);
403 visit_type_uint64(v
, name
, ptr
, errp
);
406 PropertyInfo qdev_prop_uint64
= {
410 .set_default_value
= set_default_value_uint
,
415 static void release_string(Object
*obj
, const char *name
, void *opaque
)
417 Property
*prop
= opaque
;
418 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj
), prop
));
421 static void get_string(Object
*obj
, Visitor
*v
, const char *name
,
422 void *opaque
, Error
**errp
)
424 DeviceState
*dev
= DEVICE(obj
);
425 Property
*prop
= opaque
;
426 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
429 char *str
= (char *)"";
430 visit_type_str(v
, name
, &str
, errp
);
432 visit_type_str(v
, name
, ptr
, errp
);
436 static void set_string(Object
*obj
, Visitor
*v
, const char *name
,
437 void *opaque
, Error
**errp
)
439 DeviceState
*dev
= DEVICE(obj
);
440 Property
*prop
= opaque
;
441 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
442 Error
*local_err
= NULL
;
446 qdev_prop_set_after_realize(dev
, name
, errp
);
450 visit_type_str(v
, name
, &str
, &local_err
);
452 error_propagate(errp
, local_err
);
459 PropertyInfo qdev_prop_string
= {
461 .release
= release_string
,
466 /* --- pointer --- */
468 /* Not a proper property, just for dirty hacks. TODO Remove it! */
469 PropertyInfo qdev_prop_ptr
= {
473 /* --- mac address --- */
476 * accepted syntax versions:
480 static void get_mac(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
483 DeviceState
*dev
= DEVICE(obj
);
484 Property
*prop
= opaque
;
485 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
486 char buffer
[2 * 6 + 5 + 1];
489 snprintf(buffer
, sizeof(buffer
), "%02x:%02x:%02x:%02x:%02x:%02x",
490 mac
->a
[0], mac
->a
[1], mac
->a
[2],
491 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
493 visit_type_str(v
, name
, &p
, errp
);
496 static void set_mac(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
499 DeviceState
*dev
= DEVICE(obj
);
500 Property
*prop
= opaque
;
501 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
502 Error
*local_err
= NULL
;
507 qdev_prop_set_after_realize(dev
, name
, errp
);
511 visit_type_str(v
, name
, &str
, &local_err
);
513 error_propagate(errp
, local_err
);
517 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
518 if (!qemu_isxdigit(str
[pos
])) {
521 if (!qemu_isxdigit(str
[pos
+1])) {
525 if (str
[pos
+2] != '\0') {
529 if (str
[pos
+2] != ':' && str
[pos
+2] != '-') {
533 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
539 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
543 PropertyInfo qdev_prop_macaddr
= {
545 .description
= "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
550 /* --- on/off/auto --- */
552 PropertyInfo qdev_prop_on_off_auto
= {
554 .description
= "on/off/auto",
555 .enum_table
= OnOffAuto_lookup
,
558 .set_default_value
= set_default_value_enum
,
561 /* --- lost tick policy --- */
563 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy
) != sizeof(int));
565 PropertyInfo qdev_prop_losttickpolicy
= {
566 .name
= "LostTickPolicy",
567 .enum_table
= LostTickPolicy_lookup
,
570 .set_default_value
= set_default_value_enum
,
573 /* --- Block device error handling policy --- */
575 QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError
) != sizeof(int));
577 PropertyInfo qdev_prop_blockdev_on_error
= {
578 .name
= "BlockdevOnError",
579 .description
= "Error handling policy, "
580 "report/ignore/enospc/stop/auto",
581 .enum_table
= BlockdevOnError_lookup
,
584 .set_default_value
= set_default_value_enum
,
587 /* --- BIOS CHS translation */
589 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation
) != sizeof(int));
591 PropertyInfo qdev_prop_bios_chs_trans
= {
592 .name
= "BiosAtaTranslation",
593 .description
= "Logical CHS translation algorithm, "
594 "auto/none/lba/large/rechs",
595 .enum_table
= BiosAtaTranslation_lookup
,
598 .set_default_value
= set_default_value_enum
,
601 /* --- FDC default drive types */
603 PropertyInfo qdev_prop_fdc_drive_type
= {
604 .name
= "FdcDriveType",
605 .description
= "FDC drive type, "
606 "144/288/120/none/auto",
607 .enum_table
= FloppyDriveType_lookup
,
610 .set_default_value
= set_default_value_enum
,
613 /* --- pci address --- */
616 * bus-local address, i.e. "$slot" or "$slot.$fn"
618 static void set_pci_devfn(Object
*obj
, Visitor
*v
, const char *name
,
619 void *opaque
, Error
**errp
)
621 DeviceState
*dev
= DEVICE(obj
);
622 Property
*prop
= opaque
;
623 int32_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
624 unsigned int slot
, fn
, n
;
625 Error
*local_err
= NULL
;
629 qdev_prop_set_after_realize(dev
, name
, errp
);
633 visit_type_str(v
, name
, &str
, &local_err
);
635 error_free(local_err
);
637 visit_type_int32(v
, name
, &value
, &local_err
);
639 error_propagate(errp
, local_err
);
640 } else if (value
< -1 || value
> 255) {
641 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
642 name
? name
: "null", "pci_devfn");
649 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
651 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
655 if (str
[n
] != '\0' || fn
> 7 || slot
> 31) {
658 *ptr
= slot
<< 3 | fn
;
663 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
667 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
,
670 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
673 return snprintf(dest
, len
, "<unset>");
675 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
679 PropertyInfo qdev_prop_pci_devfn
= {
681 .description
= "Slot and optional function number, example: 06.0 or 06",
682 .print
= print_pci_devfn
,
684 .set
= set_pci_devfn
,
685 .set_default_value
= set_default_value_int
,
688 /* --- blocksize --- */
690 static void set_blocksize(Object
*obj
, Visitor
*v
, const char *name
,
691 void *opaque
, Error
**errp
)
693 DeviceState
*dev
= DEVICE(obj
);
694 Property
*prop
= opaque
;
695 uint16_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
696 Error
*local_err
= NULL
;
697 const int64_t min
= 512;
698 const int64_t max
= 32768;
701 qdev_prop_set_after_realize(dev
, name
, errp
);
705 visit_type_uint16(v
, name
, &value
, &local_err
);
707 error_propagate(errp
, local_err
);
710 /* value of 0 means "unset" */
711 if (value
&& (value
< min
|| value
> max
)) {
712 error_setg(errp
, QERR_PROPERTY_VALUE_OUT_OF_RANGE
,
713 dev
->id
? : "", name
, (int64_t)value
, min
, max
);
717 /* We rely on power-of-2 blocksizes for bitmasks */
718 if ((value
& (value
- 1)) != 0) {
720 "Property %s.%s doesn't take value '%" PRId64
"', it's not a power of 2",
721 dev
->id
?: "", name
, (int64_t)value
);
728 PropertyInfo qdev_prop_blocksize
= {
730 .description
= "A power of two between 512 and 32768",
732 .set
= set_blocksize
,
733 .set_default_value
= set_default_value_uint
,
736 /* --- pci host address --- */
738 static void get_pci_host_devaddr(Object
*obj
, Visitor
*v
, const char *name
,
739 void *opaque
, Error
**errp
)
741 DeviceState
*dev
= DEVICE(obj
);
742 Property
*prop
= opaque
;
743 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
744 char buffer
[] = "ffff:ff:ff.f";
749 * Catch "invalid" device reference from vfio-pci and allow the
750 * default buffer representing the non-existent device to be used.
752 if (~addr
->domain
|| ~addr
->bus
|| ~addr
->slot
|| ~addr
->function
) {
753 rc
= snprintf(buffer
, sizeof(buffer
), "%04x:%02x:%02x.%0d",
754 addr
->domain
, addr
->bus
, addr
->slot
, addr
->function
);
755 assert(rc
== sizeof(buffer
) - 1);
758 visit_type_str(v
, name
, &p
, errp
);
762 * Parse [<domain>:]<bus>:<slot>.<func>
763 * if <domain> is not supplied, it's assumed to be 0.
765 static void set_pci_host_devaddr(Object
*obj
, Visitor
*v
, const char *name
,
766 void *opaque
, Error
**errp
)
768 DeviceState
*dev
= DEVICE(obj
);
769 Property
*prop
= opaque
;
770 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
771 Error
*local_err
= NULL
;
775 unsigned long dom
= 0, bus
= 0;
776 unsigned int slot
= 0, func
= 0;
779 qdev_prop_set_after_realize(dev
, name
, errp
);
783 visit_type_str(v
, name
, &str
, &local_err
);
785 error_propagate(errp
, local_err
);
790 val
= strtoul(p
, &e
, 16);
791 if (e
== p
|| *e
!= ':') {
797 val
= strtoul(p
, &e
, 16);
805 val
= strtoul(p
, &e
, 16);
816 val
= strtoul(p
, &e
, 10);
822 if (dom
> 0xffff || bus
> 0xff || slot
> 0x1f || func
> 7) {
833 addr
->function
= func
;
839 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
843 PropertyInfo qdev_prop_pci_host_devaddr
= {
845 .description
= "Address (bus/device/function) of "
846 "the host device, example: 04:10.0",
847 .get
= get_pci_host_devaddr
,
848 .set
= set_pci_host_devaddr
,
851 /* --- support for array properties --- */
853 /* Used as an opaque for the object properties we add for each
854 * array element. Note that the struct Property must be first
855 * in the struct so that a pointer to this works as the opaque
856 * for the underlying element's property hooks as well as for
857 * our own release callback.
860 struct Property prop
;
862 ObjectPropertyRelease
*release
;
863 } ArrayElementProperty
;
865 /* object property release callback for array element properties:
866 * we call the underlying element's property release hook, and
867 * then free the memory we allocated when we added the property.
869 static void array_element_release(Object
*obj
, const char *name
, void *opaque
)
871 ArrayElementProperty
*p
= opaque
;
873 p
->release(obj
, name
, opaque
);
879 static void set_prop_arraylen(Object
*obj
, Visitor
*v
, const char *name
,
880 void *opaque
, Error
**errp
)
882 /* Setter for the property which defines the length of a
883 * variable-sized property array. As well as actually setting the
884 * array-length field in the device struct, we have to create the
885 * array itself and dynamically add the corresponding properties.
887 DeviceState
*dev
= DEVICE(obj
);
888 Property
*prop
= opaque
;
889 uint32_t *alenptr
= qdev_get_prop_ptr(dev
, prop
);
890 void **arrayptr
= (void *)dev
+ prop
->arrayoffset
;
891 Error
*local_err
= NULL
;
893 const char *arrayname
;
897 qdev_prop_set_after_realize(dev
, name
, errp
);
901 error_setg(errp
, "array size property %s may not be set more than once",
905 visit_type_uint32(v
, name
, alenptr
, &local_err
);
907 error_propagate(errp
, local_err
);
914 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
915 * strip it off so we can get the name of the array itself.
917 assert(strncmp(name
, PROP_ARRAY_LEN_PREFIX
,
918 strlen(PROP_ARRAY_LEN_PREFIX
)) == 0);
919 arrayname
= name
+ strlen(PROP_ARRAY_LEN_PREFIX
);
921 /* Note that it is the responsibility of the individual device's deinit
922 * to free the array proper.
924 *arrayptr
= eltptr
= g_malloc0(*alenptr
* prop
->arrayfieldsize
);
925 for (i
= 0; i
< *alenptr
; i
++, eltptr
+= prop
->arrayfieldsize
) {
926 char *propname
= g_strdup_printf("%s[%d]", arrayname
, i
);
927 ArrayElementProperty
*arrayprop
= g_new0(ArrayElementProperty
, 1);
928 arrayprop
->release
= prop
->arrayinfo
->release
;
929 arrayprop
->propname
= propname
;
930 arrayprop
->prop
.info
= prop
->arrayinfo
;
931 arrayprop
->prop
.name
= propname
;
932 /* This ugly piece of pointer arithmetic sets up the offset so
933 * that when the underlying get/set hooks call qdev_get_prop_ptr
934 * they get the right answer despite the array element not actually
935 * being inside the device struct.
937 arrayprop
->prop
.offset
= eltptr
- (void *)dev
;
938 assert(qdev_get_prop_ptr(dev
, &arrayprop
->prop
) == eltptr
);
939 object_property_add(obj
, propname
,
940 arrayprop
->prop
.info
->name
,
941 arrayprop
->prop
.info
->get
,
942 arrayprop
->prop
.info
->set
,
943 array_element_release
,
944 arrayprop
, &local_err
);
946 error_propagate(errp
, local_err
);
952 PropertyInfo qdev_prop_arraylen
= {
955 .set
= set_prop_arraylen
,
956 .set_default_value
= set_default_value_uint
,
959 /* --- public helpers --- */
961 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
966 while (props
->name
) {
967 if (strcmp(props
->name
, name
) == 0) {
975 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
980 /* device properties */
981 class = object_get_class(OBJECT(dev
));
983 prop
= qdev_prop_walk(DEVICE_CLASS(class)->props
, name
);
987 class = object_class_get_parent(class);
988 } while (class != object_class_by_name(TYPE_DEVICE
));
993 void error_set_from_qdev_prop_error(Error
**errp
, int ret
, DeviceState
*dev
,
994 Property
*prop
, const char *value
)
998 error_setg(errp
, "Property '%s.%s' can't take value '%s', it's in use",
999 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1003 error_setg(errp
, QERR_PROPERTY_VALUE_BAD
,
1004 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1007 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
1008 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1015 void qdev_prop_set_bit(DeviceState
*dev
, const char *name
, bool value
)
1017 object_property_set_bool(OBJECT(dev
), value
, name
, &error_abort
);
1020 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
1022 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1025 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
1027 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1030 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
1032 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1035 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
1037 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1040 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
1042 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1045 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, const char *value
)
1047 object_property_set_str(OBJECT(dev
), value
, name
, &error_abort
);
1050 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
,
1051 const uint8_t *value
)
1053 char str
[2 * 6 + 5 + 1];
1054 snprintf(str
, sizeof(str
), "%02x:%02x:%02x:%02x:%02x:%02x",
1055 value
[0], value
[1], value
[2], value
[3], value
[4], value
[5]);
1057 object_property_set_str(OBJECT(dev
), str
, name
, &error_abort
);
1060 void qdev_prop_set_enum(DeviceState
*dev
, const char *name
, int value
)
1064 prop
= qdev_prop_find(dev
, name
);
1065 object_property_set_str(OBJECT(dev
), prop
->info
->enum_table
[value
],
1066 name
, &error_abort
);
1069 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
1074 prop
= qdev_prop_find(dev
, name
);
1075 assert(prop
&& prop
->info
== &qdev_prop_ptr
);
1076 ptr
= qdev_get_prop_ptr(dev
, prop
);
1080 static GList
*global_props
;
1082 void qdev_prop_register_global(GlobalProperty
*prop
)
1084 global_props
= g_list_append(global_props
, prop
);
1087 void qdev_prop_register_global_list(GlobalProperty
*props
)
1091 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
1092 qdev_prop_register_global(props
+i
);
1096 int qdev_prop_check_globals(void)
1101 for (l
= global_props
; l
; l
= l
->next
) {
1102 GlobalProperty
*prop
= l
->data
;
1108 if (!prop
->user_provided
) {
1111 oc
= object_class_by_name(prop
->driver
);
1112 oc
= object_class_dynamic_cast(oc
, TYPE_DEVICE
);
1114 error_report("Warning: global %s.%s has invalid class name",
1115 prop
->driver
, prop
->property
);
1119 dc
= DEVICE_CLASS(oc
);
1120 if (!dc
->hotpluggable
&& !prop
->used
) {
1121 error_report("Warning: global %s.%s=%s not used",
1122 prop
->driver
, prop
->property
, prop
->value
);
1130 static void qdev_prop_set_globals_for_type(DeviceState
*dev
,
1131 const char *typename
)
1135 for (l
= global_props
; l
; l
= l
->next
) {
1136 GlobalProperty
*prop
= l
->data
;
1139 if (strcmp(typename
, prop
->driver
) != 0) {
1143 object_property_parse(OBJECT(dev
), prop
->value
, prop
->property
, &err
);
1145 error_prepend(&err
, "can't apply global %s.%s=%s: ",
1146 prop
->driver
, prop
->property
, prop
->value
);
1147 if (!dev
->hotplugged
&& prop
->errp
) {
1148 error_propagate(prop
->errp
, err
);
1150 assert(prop
->user_provided
);
1151 error_reportf_err(err
, "Warning: ");
1157 void qdev_prop_set_globals(DeviceState
*dev
)
1159 ObjectClass
*class = object_get_class(OBJECT(dev
));
1162 qdev_prop_set_globals_for_type(dev
, object_class_get_name(class));
1163 class = object_class_get_parent(class);
1167 /* --- 64bit unsigned int 'size' type --- */
1169 static void get_size(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
1172 DeviceState
*dev
= DEVICE(obj
);
1173 Property
*prop
= opaque
;
1174 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
1176 visit_type_size(v
, name
, ptr
, errp
);
1179 static void set_size(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
1182 DeviceState
*dev
= DEVICE(obj
);
1183 Property
*prop
= opaque
;
1184 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
1186 visit_type_size(v
, name
, ptr
, errp
);
1189 PropertyInfo qdev_prop_size
= {
1193 .set_default_value
= set_default_value_uint
,