1 #include "qemu/osdep.h"
3 #include "hw/qdev-properties.h"
4 #include "qapi/error.h"
5 #include "hw/pci/pci.h"
6 #include "qapi/qapi-types-block.h"
7 #include "qapi/qapi-types-misc.h"
8 #include "qapi/qmp/qerror.h"
9 #include "qemu/ctype.h"
10 #include "qemu/error-report.h"
11 #include "hw/block/block.h"
13 #include "qapi/visitor.h"
14 #include "chardev/char.h"
15 #include "qemu/uuid.h"
17 void qdev_prop_set_after_realize(DeviceState
*dev
, const char *name
,
21 error_setg(errp
, "Attempt to set property '%s' on device '%s' "
22 "(type '%s') after it was realized", name
, dev
->id
,
23 object_get_typename(OBJECT(dev
)));
25 error_setg(errp
, "Attempt to set property '%s' on anonymous device "
26 "(type '%s') after it was realized", name
,
27 object_get_typename(OBJECT(dev
)));
31 void qdev_prop_allow_set_link_before_realize(const Object
*obj
,
33 Object
*val
, Error
**errp
)
35 DeviceState
*dev
= DEVICE(obj
);
38 error_setg(errp
, "Attempt to set link property '%s' on device '%s' "
39 "(type '%s') after it was realized",
40 name
, dev
->id
, object_get_typename(obj
));
44 void *qdev_get_prop_ptr(DeviceState
*dev
, Property
*prop
)
51 static void get_enum(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
54 DeviceState
*dev
= DEVICE(obj
);
55 Property
*prop
= opaque
;
56 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
58 visit_type_enum(v
, prop
->name
, ptr
, prop
->info
->enum_table
, errp
);
61 static void set_enum(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
64 DeviceState
*dev
= DEVICE(obj
);
65 Property
*prop
= opaque
;
66 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
69 qdev_prop_set_after_realize(dev
, name
, errp
);
73 visit_type_enum(v
, prop
->name
, ptr
, prop
->info
->enum_table
, errp
);
76 static void set_default_value_enum(Object
*obj
, const Property
*prop
)
78 object_property_set_str(obj
,
79 qapi_enum_lookup(prop
->info
->enum_table
,
81 prop
->name
, &error_abort
);
86 static uint32_t qdev_get_prop_mask(Property
*prop
)
88 assert(prop
->info
== &qdev_prop_bit
);
89 return 0x1 << prop
->bitnr
;
92 static void bit_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
94 uint32_t *p
= qdev_get_prop_ptr(dev
, props
);
95 uint32_t mask
= qdev_get_prop_mask(props
);
103 static void prop_get_bit(Object
*obj
, Visitor
*v
, const char *name
,
104 void *opaque
, Error
**errp
)
106 DeviceState
*dev
= DEVICE(obj
);
107 Property
*prop
= opaque
;
108 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
109 bool value
= (*p
& qdev_get_prop_mask(prop
)) != 0;
111 visit_type_bool(v
, name
, &value
, errp
);
114 static void prop_set_bit(Object
*obj
, Visitor
*v
, const char *name
,
115 void *opaque
, Error
**errp
)
117 DeviceState
*dev
= DEVICE(obj
);
118 Property
*prop
= opaque
;
119 Error
*local_err
= NULL
;
123 qdev_prop_set_after_realize(dev
, name
, errp
);
127 visit_type_bool(v
, name
, &value
, &local_err
);
129 error_propagate(errp
, local_err
);
132 bit_prop_set(dev
, prop
, value
);
135 static void set_default_value_bool(Object
*obj
, const Property
*prop
)
137 object_property_set_bool(obj
, prop
->defval
.u
, prop
->name
, &error_abort
);
140 const PropertyInfo qdev_prop_bit
= {
142 .description
= "on/off",
145 .set_default_value
= set_default_value_bool
,
150 static uint64_t qdev_get_prop_mask64(Property
*prop
)
152 assert(prop
->info
== &qdev_prop_bit64
);
153 return 0x1ull
<< prop
->bitnr
;
156 static void bit64_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
158 uint64_t *p
= qdev_get_prop_ptr(dev
, props
);
159 uint64_t mask
= qdev_get_prop_mask64(props
);
167 static void prop_get_bit64(Object
*obj
, Visitor
*v
, const char *name
,
168 void *opaque
, Error
**errp
)
170 DeviceState
*dev
= DEVICE(obj
);
171 Property
*prop
= opaque
;
172 uint64_t *p
= qdev_get_prop_ptr(dev
, prop
);
173 bool value
= (*p
& qdev_get_prop_mask64(prop
)) != 0;
175 visit_type_bool(v
, name
, &value
, errp
);
178 static void prop_set_bit64(Object
*obj
, Visitor
*v
, const char *name
,
179 void *opaque
, Error
**errp
)
181 DeviceState
*dev
= DEVICE(obj
);
182 Property
*prop
= opaque
;
183 Error
*local_err
= NULL
;
187 qdev_prop_set_after_realize(dev
, name
, errp
);
191 visit_type_bool(v
, name
, &value
, &local_err
);
193 error_propagate(errp
, local_err
);
196 bit64_prop_set(dev
, prop
, value
);
199 const PropertyInfo qdev_prop_bit64
= {
201 .description
= "on/off",
202 .get
= prop_get_bit64
,
203 .set
= prop_set_bit64
,
204 .set_default_value
= set_default_value_bool
,
209 static void get_bool(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
212 DeviceState
*dev
= DEVICE(obj
);
213 Property
*prop
= opaque
;
214 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
216 visit_type_bool(v
, name
, ptr
, errp
);
219 static void set_bool(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
222 DeviceState
*dev
= DEVICE(obj
);
223 Property
*prop
= opaque
;
224 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
227 qdev_prop_set_after_realize(dev
, name
, errp
);
231 visit_type_bool(v
, name
, ptr
, errp
);
234 const PropertyInfo qdev_prop_bool
= {
238 .set_default_value
= set_default_value_bool
,
241 /* --- 8bit integer --- */
243 static void get_uint8(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
246 DeviceState
*dev
= DEVICE(obj
);
247 Property
*prop
= opaque
;
248 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
250 visit_type_uint8(v
, name
, ptr
, errp
);
253 static void set_uint8(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
256 DeviceState
*dev
= DEVICE(obj
);
257 Property
*prop
= opaque
;
258 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
261 qdev_prop_set_after_realize(dev
, name
, errp
);
265 visit_type_uint8(v
, name
, ptr
, errp
);
268 static void set_default_value_int(Object
*obj
, const Property
*prop
)
270 object_property_set_int(obj
, prop
->defval
.i
, prop
->name
, &error_abort
);
273 static void set_default_value_uint(Object
*obj
, const Property
*prop
)
275 object_property_set_uint(obj
, prop
->defval
.u
, prop
->name
, &error_abort
);
278 const PropertyInfo qdev_prop_uint8
= {
282 .set_default_value
= set_default_value_uint
,
285 /* --- 16bit integer --- */
287 static void get_uint16(Object
*obj
, Visitor
*v
, const char *name
,
288 void *opaque
, Error
**errp
)
290 DeviceState
*dev
= DEVICE(obj
);
291 Property
*prop
= opaque
;
292 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
294 visit_type_uint16(v
, name
, ptr
, errp
);
297 static void set_uint16(Object
*obj
, Visitor
*v
, const char *name
,
298 void *opaque
, Error
**errp
)
300 DeviceState
*dev
= DEVICE(obj
);
301 Property
*prop
= opaque
;
302 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
305 qdev_prop_set_after_realize(dev
, name
, errp
);
309 visit_type_uint16(v
, name
, ptr
, errp
);
312 const PropertyInfo qdev_prop_uint16
= {
316 .set_default_value
= set_default_value_uint
,
319 /* --- 32bit integer --- */
321 static void get_uint32(Object
*obj
, Visitor
*v
, const char *name
,
322 void *opaque
, Error
**errp
)
324 DeviceState
*dev
= DEVICE(obj
);
325 Property
*prop
= opaque
;
326 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
328 visit_type_uint32(v
, name
, ptr
, errp
);
331 static void set_uint32(Object
*obj
, Visitor
*v
, const char *name
,
332 void *opaque
, Error
**errp
)
334 DeviceState
*dev
= DEVICE(obj
);
335 Property
*prop
= opaque
;
336 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
339 qdev_prop_set_after_realize(dev
, name
, errp
);
343 visit_type_uint32(v
, name
, ptr
, errp
);
346 static void get_int32(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
349 DeviceState
*dev
= DEVICE(obj
);
350 Property
*prop
= opaque
;
351 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
353 visit_type_int32(v
, name
, ptr
, errp
);
356 static void set_int32(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
359 DeviceState
*dev
= DEVICE(obj
);
360 Property
*prop
= opaque
;
361 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
364 qdev_prop_set_after_realize(dev
, name
, errp
);
368 visit_type_int32(v
, name
, ptr
, errp
);
371 const PropertyInfo qdev_prop_uint32
= {
375 .set_default_value
= set_default_value_uint
,
378 const PropertyInfo qdev_prop_int32
= {
382 .set_default_value
= set_default_value_int
,
385 /* --- 64bit integer --- */
387 static void get_uint64(Object
*obj
, Visitor
*v
, const char *name
,
388 void *opaque
, Error
**errp
)
390 DeviceState
*dev
= DEVICE(obj
);
391 Property
*prop
= opaque
;
392 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
394 visit_type_uint64(v
, name
, ptr
, errp
);
397 static void set_uint64(Object
*obj
, Visitor
*v
, const char *name
,
398 void *opaque
, Error
**errp
)
400 DeviceState
*dev
= DEVICE(obj
);
401 Property
*prop
= opaque
;
402 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
405 qdev_prop_set_after_realize(dev
, name
, errp
);
409 visit_type_uint64(v
, name
, ptr
, errp
);
412 static void get_int64(Object
*obj
, Visitor
*v
, const char *name
,
413 void *opaque
, Error
**errp
)
415 DeviceState
*dev
= DEVICE(obj
);
416 Property
*prop
= opaque
;
417 int64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
419 visit_type_int64(v
, name
, ptr
, errp
);
422 static void set_int64(Object
*obj
, Visitor
*v
, const char *name
,
423 void *opaque
, Error
**errp
)
425 DeviceState
*dev
= DEVICE(obj
);
426 Property
*prop
= opaque
;
427 int64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
430 qdev_prop_set_after_realize(dev
, name
, errp
);
434 visit_type_int64(v
, name
, ptr
, errp
);
437 const PropertyInfo qdev_prop_uint64
= {
441 .set_default_value
= set_default_value_uint
,
444 const PropertyInfo qdev_prop_int64
= {
448 .set_default_value
= set_default_value_int
,
453 static void release_string(Object
*obj
, const char *name
, void *opaque
)
455 Property
*prop
= opaque
;
456 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj
), prop
));
459 static void get_string(Object
*obj
, Visitor
*v
, const char *name
,
460 void *opaque
, Error
**errp
)
462 DeviceState
*dev
= DEVICE(obj
);
463 Property
*prop
= opaque
;
464 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
467 char *str
= (char *)"";
468 visit_type_str(v
, name
, &str
, errp
);
470 visit_type_str(v
, name
, ptr
, errp
);
474 static void set_string(Object
*obj
, Visitor
*v
, const char *name
,
475 void *opaque
, Error
**errp
)
477 DeviceState
*dev
= DEVICE(obj
);
478 Property
*prop
= opaque
;
479 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
480 Error
*local_err
= NULL
;
484 qdev_prop_set_after_realize(dev
, name
, errp
);
488 visit_type_str(v
, name
, &str
, &local_err
);
490 error_propagate(errp
, local_err
);
497 const PropertyInfo qdev_prop_string
= {
499 .release
= release_string
,
504 /* --- pointer --- */
506 /* Not a proper property, just for dirty hacks. TODO Remove it! */
507 const PropertyInfo qdev_prop_ptr
= {
511 /* --- mac address --- */
514 * accepted syntax versions:
518 static void get_mac(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
521 DeviceState
*dev
= DEVICE(obj
);
522 Property
*prop
= opaque
;
523 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
524 char buffer
[2 * 6 + 5 + 1];
527 snprintf(buffer
, sizeof(buffer
), "%02x:%02x:%02x:%02x:%02x:%02x",
528 mac
->a
[0], mac
->a
[1], mac
->a
[2],
529 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
531 visit_type_str(v
, name
, &p
, errp
);
534 static void set_mac(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
537 DeviceState
*dev
= DEVICE(obj
);
538 Property
*prop
= opaque
;
539 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
540 Error
*local_err
= NULL
;
545 qdev_prop_set_after_realize(dev
, name
, errp
);
549 visit_type_str(v
, name
, &str
, &local_err
);
551 error_propagate(errp
, local_err
);
555 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
556 if (!qemu_isxdigit(str
[pos
])) {
559 if (!qemu_isxdigit(str
[pos
+1])) {
563 if (str
[pos
+2] != '\0') {
567 if (str
[pos
+2] != ':' && str
[pos
+2] != '-') {
571 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
577 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
581 const PropertyInfo qdev_prop_macaddr
= {
583 .description
= "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
588 /* --- on/off/auto --- */
590 const PropertyInfo qdev_prop_on_off_auto
= {
592 .description
= "on/off/auto",
593 .enum_table
= &OnOffAuto_lookup
,
596 .set_default_value
= set_default_value_enum
,
599 /* --- lost tick policy --- */
601 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy
) != sizeof(int));
603 const PropertyInfo qdev_prop_losttickpolicy
= {
604 .name
= "LostTickPolicy",
605 .enum_table
= &LostTickPolicy_lookup
,
608 .set_default_value
= set_default_value_enum
,
611 /* --- Block device error handling policy --- */
613 QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError
) != sizeof(int));
615 const PropertyInfo qdev_prop_blockdev_on_error
= {
616 .name
= "BlockdevOnError",
617 .description
= "Error handling policy, "
618 "report/ignore/enospc/stop/auto",
619 .enum_table
= &BlockdevOnError_lookup
,
622 .set_default_value
= set_default_value_enum
,
625 /* --- BIOS CHS translation */
627 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation
) != sizeof(int));
629 const PropertyInfo qdev_prop_bios_chs_trans
= {
630 .name
= "BiosAtaTranslation",
631 .description
= "Logical CHS translation algorithm, "
632 "auto/none/lba/large/rechs",
633 .enum_table
= &BiosAtaTranslation_lookup
,
636 .set_default_value
= set_default_value_enum
,
639 /* --- FDC default drive types */
641 const PropertyInfo qdev_prop_fdc_drive_type
= {
642 .name
= "FdcDriveType",
643 .description
= "FDC drive type, "
644 "144/288/120/none/auto",
645 .enum_table
= &FloppyDriveType_lookup
,
648 .set_default_value
= set_default_value_enum
,
651 /* --- pci address --- */
654 * bus-local address, i.e. "$slot" or "$slot.$fn"
656 static void set_pci_devfn(Object
*obj
, Visitor
*v
, const char *name
,
657 void *opaque
, Error
**errp
)
659 DeviceState
*dev
= DEVICE(obj
);
660 Property
*prop
= opaque
;
661 int32_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
662 unsigned int slot
, fn
, n
;
663 Error
*local_err
= NULL
;
667 qdev_prop_set_after_realize(dev
, name
, errp
);
671 visit_type_str(v
, name
, &str
, &local_err
);
673 error_free(local_err
);
675 visit_type_int32(v
, name
, &value
, &local_err
);
677 error_propagate(errp
, local_err
);
678 } else if (value
< -1 || value
> 255) {
679 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
680 name
? name
: "null", "pci_devfn");
687 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
689 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
693 if (str
[n
] != '\0' || fn
> 7 || slot
> 31) {
696 *ptr
= slot
<< 3 | fn
;
701 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
705 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
,
708 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
711 return snprintf(dest
, len
, "<unset>");
713 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
717 const PropertyInfo qdev_prop_pci_devfn
= {
719 .description
= "Slot and optional function number, example: 06.0 or 06",
720 .print
= print_pci_devfn
,
722 .set
= set_pci_devfn
,
723 .set_default_value
= set_default_value_int
,
726 /* --- blocksize --- */
728 static void set_blocksize(Object
*obj
, Visitor
*v
, const char *name
,
729 void *opaque
, Error
**errp
)
731 DeviceState
*dev
= DEVICE(obj
);
732 Property
*prop
= opaque
;
733 uint16_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
734 Error
*local_err
= NULL
;
735 const int64_t min
= 512;
736 const int64_t max
= 32768;
739 qdev_prop_set_after_realize(dev
, name
, errp
);
743 visit_type_uint16(v
, name
, &value
, &local_err
);
745 error_propagate(errp
, local_err
);
748 /* value of 0 means "unset" */
749 if (value
&& (value
< min
|| value
> max
)) {
750 error_setg(errp
, QERR_PROPERTY_VALUE_OUT_OF_RANGE
,
751 dev
->id
? : "", name
, (int64_t)value
, min
, max
);
755 /* We rely on power-of-2 blocksizes for bitmasks */
756 if ((value
& (value
- 1)) != 0) {
758 "Property %s.%s doesn't take value '%" PRId64
"', it's not a power of 2",
759 dev
->id
?: "", name
, (int64_t)value
);
766 const PropertyInfo qdev_prop_blocksize
= {
768 .description
= "A power of two between 512 and 32768",
770 .set
= set_blocksize
,
771 .set_default_value
= set_default_value_uint
,
774 /* --- pci host address --- */
776 static void get_pci_host_devaddr(Object
*obj
, Visitor
*v
, const char *name
,
777 void *opaque
, Error
**errp
)
779 DeviceState
*dev
= DEVICE(obj
);
780 Property
*prop
= opaque
;
781 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
782 char buffer
[] = "ffff:ff:ff.f";
787 * Catch "invalid" device reference from vfio-pci and allow the
788 * default buffer representing the non-existent device to be used.
790 if (~addr
->domain
|| ~addr
->bus
|| ~addr
->slot
|| ~addr
->function
) {
791 rc
= snprintf(buffer
, sizeof(buffer
), "%04x:%02x:%02x.%0d",
792 addr
->domain
, addr
->bus
, addr
->slot
, addr
->function
);
793 assert(rc
== sizeof(buffer
) - 1);
796 visit_type_str(v
, name
, &p
, errp
);
800 * Parse [<domain>:]<bus>:<slot>.<func>
801 * if <domain> is not supplied, it's assumed to be 0.
803 static void set_pci_host_devaddr(Object
*obj
, Visitor
*v
, const char *name
,
804 void *opaque
, Error
**errp
)
806 DeviceState
*dev
= DEVICE(obj
);
807 Property
*prop
= opaque
;
808 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
809 Error
*local_err
= NULL
;
813 unsigned long dom
= 0, bus
= 0;
814 unsigned int slot
= 0, func
= 0;
817 qdev_prop_set_after_realize(dev
, name
, errp
);
821 visit_type_str(v
, name
, &str
, &local_err
);
823 error_propagate(errp
, local_err
);
828 val
= strtoul(p
, &e
, 16);
829 if (e
== p
|| *e
!= ':') {
835 val
= strtoul(p
, &e
, 16);
843 val
= strtoul(p
, &e
, 16);
854 val
= strtoul(p
, &e
, 10);
860 if (dom
> 0xffff || bus
> 0xff || slot
> 0x1f || func
> 7) {
871 addr
->function
= func
;
877 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
881 const PropertyInfo qdev_prop_pci_host_devaddr
= {
883 .description
= "Address (bus/device/function) of "
884 "the host device, example: 04:10.0",
885 .get
= get_pci_host_devaddr
,
886 .set
= set_pci_host_devaddr
,
891 static void get_uuid(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
894 DeviceState
*dev
= DEVICE(obj
);
895 Property
*prop
= opaque
;
896 QemuUUID
*uuid
= qdev_get_prop_ptr(dev
, prop
);
897 char buffer
[UUID_FMT_LEN
+ 1];
900 qemu_uuid_unparse(uuid
, buffer
);
902 visit_type_str(v
, name
, &p
, errp
);
905 #define UUID_VALUE_AUTO "auto"
907 static void set_uuid(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
910 DeviceState
*dev
= DEVICE(obj
);
911 Property
*prop
= opaque
;
912 QemuUUID
*uuid
= qdev_get_prop_ptr(dev
, prop
);
913 Error
*local_err
= NULL
;
917 qdev_prop_set_after_realize(dev
, name
, errp
);
921 visit_type_str(v
, name
, &str
, &local_err
);
923 error_propagate(errp
, local_err
);
927 if (!strcmp(str
, UUID_VALUE_AUTO
)) {
928 qemu_uuid_generate(uuid
);
929 } else if (qemu_uuid_parse(str
, uuid
) < 0) {
930 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
935 static void set_default_uuid_auto(Object
*obj
, const Property
*prop
)
937 object_property_set_str(obj
, UUID_VALUE_AUTO
, prop
->name
, &error_abort
);
940 const PropertyInfo qdev_prop_uuid
= {
942 .description
= "UUID (aka GUID) or \"" UUID_VALUE_AUTO
943 "\" for random value (default)",
946 .set_default_value
= set_default_uuid_auto
,
949 /* --- support for array properties --- */
951 /* Used as an opaque for the object properties we add for each
952 * array element. Note that the struct Property must be first
953 * in the struct so that a pointer to this works as the opaque
954 * for the underlying element's property hooks as well as for
955 * our own release callback.
958 struct Property prop
;
960 ObjectPropertyRelease
*release
;
961 } ArrayElementProperty
;
963 /* object property release callback for array element properties:
964 * we call the underlying element's property release hook, and
965 * then free the memory we allocated when we added the property.
967 static void array_element_release(Object
*obj
, const char *name
, void *opaque
)
969 ArrayElementProperty
*p
= opaque
;
971 p
->release(obj
, name
, opaque
);
977 static void set_prop_arraylen(Object
*obj
, Visitor
*v
, const char *name
,
978 void *opaque
, Error
**errp
)
980 /* Setter for the property which defines the length of a
981 * variable-sized property array. As well as actually setting the
982 * array-length field in the device struct, we have to create the
983 * array itself and dynamically add the corresponding properties.
985 DeviceState
*dev
= DEVICE(obj
);
986 Property
*prop
= opaque
;
987 uint32_t *alenptr
= qdev_get_prop_ptr(dev
, prop
);
988 void **arrayptr
= (void *)dev
+ prop
->arrayoffset
;
989 Error
*local_err
= NULL
;
991 const char *arrayname
;
995 qdev_prop_set_after_realize(dev
, name
, errp
);
999 error_setg(errp
, "array size property %s may not be set more than once",
1003 visit_type_uint32(v
, name
, alenptr
, &local_err
);
1005 error_propagate(errp
, local_err
);
1012 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
1013 * strip it off so we can get the name of the array itself.
1015 assert(strncmp(name
, PROP_ARRAY_LEN_PREFIX
,
1016 strlen(PROP_ARRAY_LEN_PREFIX
)) == 0);
1017 arrayname
= name
+ strlen(PROP_ARRAY_LEN_PREFIX
);
1019 /* Note that it is the responsibility of the individual device's deinit
1020 * to free the array proper.
1022 *arrayptr
= eltptr
= g_malloc0(*alenptr
* prop
->arrayfieldsize
);
1023 for (i
= 0; i
< *alenptr
; i
++, eltptr
+= prop
->arrayfieldsize
) {
1024 char *propname
= g_strdup_printf("%s[%d]", arrayname
, i
);
1025 ArrayElementProperty
*arrayprop
= g_new0(ArrayElementProperty
, 1);
1026 arrayprop
->release
= prop
->arrayinfo
->release
;
1027 arrayprop
->propname
= propname
;
1028 arrayprop
->prop
.info
= prop
->arrayinfo
;
1029 arrayprop
->prop
.name
= propname
;
1030 /* This ugly piece of pointer arithmetic sets up the offset so
1031 * that when the underlying get/set hooks call qdev_get_prop_ptr
1032 * they get the right answer despite the array element not actually
1033 * being inside the device struct.
1035 arrayprop
->prop
.offset
= eltptr
- (void *)dev
;
1036 assert(qdev_get_prop_ptr(dev
, &arrayprop
->prop
) == eltptr
);
1037 object_property_add(obj
, propname
,
1038 arrayprop
->prop
.info
->name
,
1039 arrayprop
->prop
.info
->get
,
1040 arrayprop
->prop
.info
->set
,
1041 array_element_release
,
1042 arrayprop
, &local_err
);
1044 error_propagate(errp
, local_err
);
1050 const PropertyInfo qdev_prop_arraylen
= {
1053 .set
= set_prop_arraylen
,
1054 .set_default_value
= set_default_value_uint
,
1057 /* --- public helpers --- */
1059 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
1064 while (props
->name
) {
1065 if (strcmp(props
->name
, name
) == 0) {
1073 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
1078 /* device properties */
1079 class = object_get_class(OBJECT(dev
));
1081 prop
= qdev_prop_walk(DEVICE_CLASS(class)->props
, name
);
1085 class = object_class_get_parent(class);
1086 } while (class != object_class_by_name(TYPE_DEVICE
));
1091 void error_set_from_qdev_prop_error(Error
**errp
, int ret
, DeviceState
*dev
,
1092 Property
*prop
, const char *value
)
1096 error_setg(errp
, "Property '%s.%s' can't take value '%s', it's in use",
1097 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1101 error_setg(errp
, QERR_PROPERTY_VALUE_BAD
,
1102 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1105 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
1106 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1113 void qdev_prop_set_bit(DeviceState
*dev
, const char *name
, bool value
)
1115 object_property_set_bool(OBJECT(dev
), value
, name
, &error_abort
);
1118 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
1120 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1123 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
1125 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1128 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
1130 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1133 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
1135 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1138 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
1140 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
1143 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, const char *value
)
1145 object_property_set_str(OBJECT(dev
), value
, name
, &error_abort
);
1148 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
,
1149 const uint8_t *value
)
1151 char str
[2 * 6 + 5 + 1];
1152 snprintf(str
, sizeof(str
), "%02x:%02x:%02x:%02x:%02x:%02x",
1153 value
[0], value
[1], value
[2], value
[3], value
[4], value
[5]);
1155 object_property_set_str(OBJECT(dev
), str
, name
, &error_abort
);
1158 void qdev_prop_set_enum(DeviceState
*dev
, const char *name
, int value
)
1162 prop
= qdev_prop_find(dev
, name
);
1163 object_property_set_str(OBJECT(dev
),
1164 qapi_enum_lookup(prop
->info
->enum_table
, value
),
1165 name
, &error_abort
);
1168 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
1173 prop
= qdev_prop_find(dev
, name
);
1174 assert(prop
&& prop
->info
== &qdev_prop_ptr
);
1175 ptr
= qdev_get_prop_ptr(dev
, prop
);
1179 static GPtrArray
*global_props(void)
1181 static GPtrArray
*gp
;
1184 gp
= g_ptr_array_new();
1190 void qdev_prop_register_global(GlobalProperty
*prop
)
1192 g_ptr_array_add(global_props(), prop
);
1195 int qdev_prop_check_globals(void)
1199 for (i
= 0; i
< global_props()->len
; i
++) {
1200 GlobalProperty
*prop
;
1204 prop
= g_ptr_array_index(global_props(), i
);
1208 oc
= object_class_by_name(prop
->driver
);
1209 oc
= object_class_dynamic_cast(oc
, TYPE_DEVICE
);
1211 warn_report("global %s.%s has invalid class name",
1212 prop
->driver
, prop
->property
);
1216 dc
= DEVICE_CLASS(oc
);
1217 if (!dc
->hotpluggable
&& !prop
->used
) {
1218 warn_report("global %s.%s=%s not used",
1219 prop
->driver
, prop
->property
, prop
->value
);
1227 void qdev_prop_set_globals(DeviceState
*dev
)
1229 object_apply_global_props(OBJECT(dev
), global_props(),
1230 dev
->hotplugged
? NULL
: &error_fatal
);
1233 /* --- 64bit unsigned int 'size' type --- */
1235 static void get_size(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
1238 DeviceState
*dev
= DEVICE(obj
);
1239 Property
*prop
= opaque
;
1240 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
1242 visit_type_size(v
, name
, ptr
, errp
);
1245 static void set_size(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
1248 DeviceState
*dev
= DEVICE(obj
);
1249 Property
*prop
= opaque
;
1250 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
1252 visit_type_size(v
, name
, ptr
, errp
);
1255 const PropertyInfo qdev_prop_size
= {
1259 .set_default_value
= set_default_value_uint
,
1262 /* --- object link property --- */
1264 static void create_link_property(Object
*obj
, Property
*prop
, Error
**errp
)
1266 Object
**child
= qdev_get_prop_ptr(DEVICE(obj
), prop
);
1268 object_property_add_link(obj
, prop
->name
, prop
->link_type
,
1270 qdev_prop_allow_set_link_before_realize
,
1271 OBJ_PROP_LINK_STRONG
,
1275 const PropertyInfo qdev_prop_link
= {
1277 .create
= create_link_property
,
1280 /* --- OffAutoPCIBAR off/auto/bar0/bar1/bar2/bar3/bar4/bar5 --- */
1282 const PropertyInfo qdev_prop_off_auto_pcibar
= {
1283 .name
= "OffAutoPCIBAR",
1284 .description
= "off/auto/bar0/bar1/bar2/bar3/bar4/bar5",
1285 .enum_table
= &OffAutoPCIBAR_lookup
,
1288 .set_default_value
= set_default_value_enum
,
1291 /* --- PCIELinkSpeed 2_5/5/8/16 -- */
1293 static void get_prop_pcielinkspeed(Object
*obj
, Visitor
*v
, const char *name
,
1294 void *opaque
, Error
**errp
)
1296 DeviceState
*dev
= DEVICE(obj
);
1297 Property
*prop
= opaque
;
1298 PCIExpLinkSpeed
*p
= qdev_get_prop_ptr(dev
, prop
);
1302 case QEMU_PCI_EXP_LNK_2_5GT
:
1303 speed
= PCIE_LINK_SPEED_2_5
;
1305 case QEMU_PCI_EXP_LNK_5GT
:
1306 speed
= PCIE_LINK_SPEED_5
;
1308 case QEMU_PCI_EXP_LNK_8GT
:
1309 speed
= PCIE_LINK_SPEED_8
;
1311 case QEMU_PCI_EXP_LNK_16GT
:
1312 speed
= PCIE_LINK_SPEED_16
;
1319 visit_type_enum(v
, prop
->name
, &speed
, prop
->info
->enum_table
, errp
);
1322 static void set_prop_pcielinkspeed(Object
*obj
, Visitor
*v
, const char *name
,
1323 void *opaque
, Error
**errp
)
1325 DeviceState
*dev
= DEVICE(obj
);
1326 Property
*prop
= opaque
;
1327 PCIExpLinkSpeed
*p
= qdev_get_prop_ptr(dev
, prop
);
1329 Error
*local_err
= NULL
;
1331 if (dev
->realized
) {
1332 qdev_prop_set_after_realize(dev
, name
, errp
);
1336 visit_type_enum(v
, prop
->name
, &speed
, prop
->info
->enum_table
, &local_err
);
1338 error_propagate(errp
, local_err
);
1343 case PCIE_LINK_SPEED_2_5
:
1344 *p
= QEMU_PCI_EXP_LNK_2_5GT
;
1346 case PCIE_LINK_SPEED_5
:
1347 *p
= QEMU_PCI_EXP_LNK_5GT
;
1349 case PCIE_LINK_SPEED_8
:
1350 *p
= QEMU_PCI_EXP_LNK_8GT
;
1352 case PCIE_LINK_SPEED_16
:
1353 *p
= QEMU_PCI_EXP_LNK_16GT
;
1361 const PropertyInfo qdev_prop_pcie_link_speed
= {
1362 .name
= "PCIELinkSpeed",
1363 .description
= "2_5/5/8/16",
1364 .enum_table
= &PCIELinkSpeed_lookup
,
1365 .get
= get_prop_pcielinkspeed
,
1366 .set
= set_prop_pcielinkspeed
,
1367 .set_default_value
= set_default_value_enum
,
1370 /* --- PCIELinkWidth 1/2/4/8/12/16/32 -- */
1372 static void get_prop_pcielinkwidth(Object
*obj
, Visitor
*v
, const char *name
,
1373 void *opaque
, Error
**errp
)
1375 DeviceState
*dev
= DEVICE(obj
);
1376 Property
*prop
= opaque
;
1377 PCIExpLinkWidth
*p
= qdev_get_prop_ptr(dev
, prop
);
1381 case QEMU_PCI_EXP_LNK_X1
:
1382 width
= PCIE_LINK_WIDTH_1
;
1384 case QEMU_PCI_EXP_LNK_X2
:
1385 width
= PCIE_LINK_WIDTH_2
;
1387 case QEMU_PCI_EXP_LNK_X4
:
1388 width
= PCIE_LINK_WIDTH_4
;
1390 case QEMU_PCI_EXP_LNK_X8
:
1391 width
= PCIE_LINK_WIDTH_8
;
1393 case QEMU_PCI_EXP_LNK_X12
:
1394 width
= PCIE_LINK_WIDTH_12
;
1396 case QEMU_PCI_EXP_LNK_X16
:
1397 width
= PCIE_LINK_WIDTH_16
;
1399 case QEMU_PCI_EXP_LNK_X32
:
1400 width
= PCIE_LINK_WIDTH_32
;
1407 visit_type_enum(v
, prop
->name
, &width
, prop
->info
->enum_table
, errp
);
1410 static void set_prop_pcielinkwidth(Object
*obj
, Visitor
*v
, const char *name
,
1411 void *opaque
, Error
**errp
)
1413 DeviceState
*dev
= DEVICE(obj
);
1414 Property
*prop
= opaque
;
1415 PCIExpLinkWidth
*p
= qdev_get_prop_ptr(dev
, prop
);
1417 Error
*local_err
= NULL
;
1419 if (dev
->realized
) {
1420 qdev_prop_set_after_realize(dev
, name
, errp
);
1424 visit_type_enum(v
, prop
->name
, &width
, prop
->info
->enum_table
, &local_err
);
1426 error_propagate(errp
, local_err
);
1431 case PCIE_LINK_WIDTH_1
:
1432 *p
= QEMU_PCI_EXP_LNK_X1
;
1434 case PCIE_LINK_WIDTH_2
:
1435 *p
= QEMU_PCI_EXP_LNK_X2
;
1437 case PCIE_LINK_WIDTH_4
:
1438 *p
= QEMU_PCI_EXP_LNK_X4
;
1440 case PCIE_LINK_WIDTH_8
:
1441 *p
= QEMU_PCI_EXP_LNK_X8
;
1443 case PCIE_LINK_WIDTH_12
:
1444 *p
= QEMU_PCI_EXP_LNK_X12
;
1446 case PCIE_LINK_WIDTH_16
:
1447 *p
= QEMU_PCI_EXP_LNK_X16
;
1449 case PCIE_LINK_WIDTH_32
:
1450 *p
= QEMU_PCI_EXP_LNK_X32
;
1458 const PropertyInfo qdev_prop_pcie_link_width
= {
1459 .name
= "PCIELinkWidth",
1460 .description
= "1/2/4/8/12/16/32",
1461 .enum_table
= &PCIELinkWidth_lookup
,
1462 .get
= get_prop_pcielinkwidth
,
1463 .set
= set_prop_pcielinkwidth
,
1464 .set_default_value
= set_default_value_enum
,