1 #include "qemu/osdep.h"
2 #include "hw/qdev-properties.h"
3 #include "qapi/error.h"
4 #include "qapi/qapi-types-misc.h"
5 #include "qapi/qmp/qerror.h"
6 #include "qemu/ctype.h"
7 #include "qemu/error-report.h"
8 #include "qapi/visitor.h"
10 #include "qemu/units.h"
11 #include "qemu/cutils.h"
12 #include "qdev-prop-internal.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(const Object
*obj
,
30 Object
*val
, Error
**errp
)
32 DeviceState
*dev
= DEVICE(obj
);
35 error_setg(errp
, "Attempt to set link property '%s' on device '%s' "
36 "(type '%s') after it was realized",
37 name
, dev
->id
, object_get_typename(obj
));
41 void *qdev_get_prop_ptr(DeviceState
*dev
, Property
*prop
)
48 void qdev_propinfo_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
49 void *opaque
, Error
**errp
)
51 DeviceState
*dev
= DEVICE(obj
);
52 Property
*prop
= opaque
;
53 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
55 visit_type_enum(v
, prop
->name
, ptr
, prop
->info
->enum_table
, errp
);
58 void qdev_propinfo_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
59 void *opaque
, Error
**errp
)
61 DeviceState
*dev
= DEVICE(obj
);
62 Property
*prop
= opaque
;
63 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
66 qdev_prop_set_after_realize(dev
, name
, errp
);
70 visit_type_enum(v
, prop
->name
, ptr
, prop
->info
->enum_table
, errp
);
73 void qdev_propinfo_set_default_value_enum(ObjectProperty
*op
,
76 object_property_set_default_str(op
,
77 qapi_enum_lookup(prop
->info
->enum_table
, prop
->defval
.i
));
80 const PropertyInfo qdev_prop_enum
= {
82 .get
= qdev_propinfo_get_enum
,
83 .set
= qdev_propinfo_set_enum
,
84 .set_default_value
= qdev_propinfo_set_default_value_enum
,
89 static uint32_t qdev_get_prop_mask(Property
*prop
)
91 assert(prop
->info
== &qdev_prop_bit
);
92 return 0x1 << prop
->bitnr
;
95 static void bit_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
97 uint32_t *p
= qdev_get_prop_ptr(dev
, props
);
98 uint32_t mask
= qdev_get_prop_mask(props
);
106 static void prop_get_bit(Object
*obj
, Visitor
*v
, const char *name
,
107 void *opaque
, Error
**errp
)
109 DeviceState
*dev
= DEVICE(obj
);
110 Property
*prop
= opaque
;
111 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
112 bool value
= (*p
& qdev_get_prop_mask(prop
)) != 0;
114 visit_type_bool(v
, name
, &value
, errp
);
117 static void prop_set_bit(Object
*obj
, Visitor
*v
, const char *name
,
118 void *opaque
, Error
**errp
)
120 DeviceState
*dev
= DEVICE(obj
);
121 Property
*prop
= opaque
;
125 qdev_prop_set_after_realize(dev
, name
, errp
);
129 if (!visit_type_bool(v
, name
, &value
, errp
)) {
132 bit_prop_set(dev
, prop
, value
);
135 static void set_default_value_bool(ObjectProperty
*op
, const Property
*prop
)
137 object_property_set_default_bool(op
, prop
->defval
.u
);
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
;
186 qdev_prop_set_after_realize(dev
, name
, errp
);
190 if (!visit_type_bool(v
, name
, &value
, errp
)) {
193 bit64_prop_set(dev
, prop
, value
);
196 const PropertyInfo qdev_prop_bit64
= {
198 .description
= "on/off",
199 .get
= prop_get_bit64
,
200 .set
= prop_set_bit64
,
201 .set_default_value
= set_default_value_bool
,
206 static void get_bool(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
209 DeviceState
*dev
= DEVICE(obj
);
210 Property
*prop
= opaque
;
211 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
213 visit_type_bool(v
, name
, ptr
, errp
);
216 static void set_bool(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
219 DeviceState
*dev
= DEVICE(obj
);
220 Property
*prop
= opaque
;
221 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
224 qdev_prop_set_after_realize(dev
, name
, errp
);
228 visit_type_bool(v
, name
, ptr
, errp
);
231 const PropertyInfo qdev_prop_bool
= {
235 .set_default_value
= set_default_value_bool
,
238 /* --- 8bit integer --- */
240 static void get_uint8(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
243 DeviceState
*dev
= DEVICE(obj
);
244 Property
*prop
= opaque
;
245 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
247 visit_type_uint8(v
, name
, ptr
, errp
);
250 static void set_uint8(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
253 DeviceState
*dev
= DEVICE(obj
);
254 Property
*prop
= opaque
;
255 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
258 qdev_prop_set_after_realize(dev
, name
, errp
);
262 visit_type_uint8(v
, name
, ptr
, errp
);
265 void qdev_propinfo_set_default_value_int(ObjectProperty
*op
,
266 const Property
*prop
)
268 object_property_set_default_int(op
, prop
->defval
.i
);
271 void qdev_propinfo_set_default_value_uint(ObjectProperty
*op
,
272 const Property
*prop
)
274 object_property_set_default_uint(op
, prop
->defval
.u
);
277 const PropertyInfo qdev_prop_uint8
= {
281 .set_default_value
= qdev_propinfo_set_default_value_uint
,
284 /* --- 16bit integer --- */
286 void qdev_propinfo_get_uint16(Object
*obj
, Visitor
*v
, const char *name
,
287 void *opaque
, Error
**errp
)
289 DeviceState
*dev
= DEVICE(obj
);
290 Property
*prop
= opaque
;
291 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
293 visit_type_uint16(v
, name
, ptr
, errp
);
296 static void set_uint16(Object
*obj
, Visitor
*v
, const char *name
,
297 void *opaque
, Error
**errp
)
299 DeviceState
*dev
= DEVICE(obj
);
300 Property
*prop
= opaque
;
301 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
304 qdev_prop_set_after_realize(dev
, name
, errp
);
308 visit_type_uint16(v
, name
, ptr
, errp
);
311 const PropertyInfo qdev_prop_uint16
= {
313 .get
= qdev_propinfo_get_uint16
,
315 .set_default_value
= qdev_propinfo_set_default_value_uint
,
318 /* --- 32bit integer --- */
320 static void get_uint32(Object
*obj
, Visitor
*v
, const char *name
,
321 void *opaque
, Error
**errp
)
323 DeviceState
*dev
= DEVICE(obj
);
324 Property
*prop
= opaque
;
325 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
327 visit_type_uint32(v
, name
, ptr
, errp
);
330 static void set_uint32(Object
*obj
, Visitor
*v
, const char *name
,
331 void *opaque
, Error
**errp
)
333 DeviceState
*dev
= DEVICE(obj
);
334 Property
*prop
= opaque
;
335 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
338 qdev_prop_set_after_realize(dev
, name
, errp
);
342 visit_type_uint32(v
, name
, ptr
, errp
);
345 void qdev_propinfo_get_int32(Object
*obj
, Visitor
*v
, const char *name
,
346 void *opaque
, Error
**errp
)
348 DeviceState
*dev
= DEVICE(obj
);
349 Property
*prop
= opaque
;
350 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
352 visit_type_int32(v
, name
, ptr
, errp
);
355 static void set_int32(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
358 DeviceState
*dev
= DEVICE(obj
);
359 Property
*prop
= opaque
;
360 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
363 qdev_prop_set_after_realize(dev
, name
, errp
);
367 visit_type_int32(v
, name
, ptr
, errp
);
370 const PropertyInfo qdev_prop_uint32
= {
374 .set_default_value
= qdev_propinfo_set_default_value_uint
,
377 const PropertyInfo qdev_prop_int32
= {
379 .get
= qdev_propinfo_get_int32
,
381 .set_default_value
= qdev_propinfo_set_default_value_int
,
384 /* --- 64bit integer --- */
386 static void get_uint64(Object
*obj
, Visitor
*v
, const char *name
,
387 void *opaque
, Error
**errp
)
389 DeviceState
*dev
= DEVICE(obj
);
390 Property
*prop
= opaque
;
391 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
393 visit_type_uint64(v
, name
, ptr
, errp
);
396 static void set_uint64(Object
*obj
, Visitor
*v
, const char *name
,
397 void *opaque
, Error
**errp
)
399 DeviceState
*dev
= DEVICE(obj
);
400 Property
*prop
= opaque
;
401 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
404 qdev_prop_set_after_realize(dev
, name
, errp
);
408 visit_type_uint64(v
, name
, ptr
, errp
);
411 static void get_int64(Object
*obj
, Visitor
*v
, const char *name
,
412 void *opaque
, Error
**errp
)
414 DeviceState
*dev
= DEVICE(obj
);
415 Property
*prop
= opaque
;
416 int64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
418 visit_type_int64(v
, name
, ptr
, errp
);
421 static void set_int64(Object
*obj
, Visitor
*v
, const char *name
,
422 void *opaque
, Error
**errp
)
424 DeviceState
*dev
= DEVICE(obj
);
425 Property
*prop
= opaque
;
426 int64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
429 qdev_prop_set_after_realize(dev
, name
, errp
);
433 visit_type_int64(v
, name
, ptr
, errp
);
436 const PropertyInfo qdev_prop_uint64
= {
440 .set_default_value
= qdev_propinfo_set_default_value_uint
,
443 const PropertyInfo qdev_prop_int64
= {
447 .set_default_value
= qdev_propinfo_set_default_value_int
,
452 static void release_string(Object
*obj
, const char *name
, void *opaque
)
454 Property
*prop
= opaque
;
455 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj
), prop
));
458 static void get_string(Object
*obj
, Visitor
*v
, const char *name
,
459 void *opaque
, Error
**errp
)
461 DeviceState
*dev
= DEVICE(obj
);
462 Property
*prop
= opaque
;
463 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
466 char *str
= (char *)"";
467 visit_type_str(v
, name
, &str
, errp
);
469 visit_type_str(v
, name
, ptr
, errp
);
473 static void set_string(Object
*obj
, Visitor
*v
, const char *name
,
474 void *opaque
, Error
**errp
)
476 DeviceState
*dev
= DEVICE(obj
);
477 Property
*prop
= opaque
;
478 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
482 qdev_prop_set_after_realize(dev
, name
, errp
);
486 if (!visit_type_str(v
, name
, &str
, errp
)) {
493 const PropertyInfo qdev_prop_string
= {
495 .release
= release_string
,
500 /* --- on/off/auto --- */
502 const PropertyInfo qdev_prop_on_off_auto
= {
504 .description
= "on/off/auto",
505 .enum_table
= &OnOffAuto_lookup
,
506 .get
= qdev_propinfo_get_enum
,
507 .set
= qdev_propinfo_set_enum
,
508 .set_default_value
= qdev_propinfo_set_default_value_enum
,
511 /* --- 32bit unsigned int 'size' type --- */
513 void qdev_propinfo_get_size32(Object
*obj
, Visitor
*v
, const char *name
,
514 void *opaque
, Error
**errp
)
516 DeviceState
*dev
= DEVICE(obj
);
517 Property
*prop
= opaque
;
518 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
519 uint64_t value
= *ptr
;
521 visit_type_size(v
, name
, &value
, errp
);
524 static void set_size32(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
527 DeviceState
*dev
= DEVICE(obj
);
528 Property
*prop
= opaque
;
529 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
533 qdev_prop_set_after_realize(dev
, name
, errp
);
537 if (!visit_type_size(v
, name
, &value
, errp
)) {
541 if (value
> UINT32_MAX
) {
543 "Property %s.%s doesn't take value %" PRIu64
545 dev
->id
? : "", name
, value
, UINT32_MAX
);
552 const PropertyInfo qdev_prop_size32
= {
554 .get
= qdev_propinfo_get_size32
,
556 .set_default_value
= qdev_propinfo_set_default_value_uint
,
561 static void get_uuid(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
564 DeviceState
*dev
= DEVICE(obj
);
565 Property
*prop
= opaque
;
566 QemuUUID
*uuid
= qdev_get_prop_ptr(dev
, prop
);
567 char buffer
[UUID_FMT_LEN
+ 1];
570 qemu_uuid_unparse(uuid
, buffer
);
572 visit_type_str(v
, name
, &p
, errp
);
575 #define UUID_VALUE_AUTO "auto"
577 static void set_uuid(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
580 DeviceState
*dev
= DEVICE(obj
);
581 Property
*prop
= opaque
;
582 QemuUUID
*uuid
= qdev_get_prop_ptr(dev
, prop
);
586 qdev_prop_set_after_realize(dev
, name
, errp
);
590 if (!visit_type_str(v
, name
, &str
, errp
)) {
594 if (!strcmp(str
, UUID_VALUE_AUTO
)) {
595 qemu_uuid_generate(uuid
);
596 } else if (qemu_uuid_parse(str
, uuid
) < 0) {
597 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
602 static void set_default_uuid_auto(ObjectProperty
*op
, const Property
*prop
)
604 object_property_set_default_str(op
, UUID_VALUE_AUTO
);
607 const PropertyInfo qdev_prop_uuid
= {
609 .description
= "UUID (aka GUID) or \"" UUID_VALUE_AUTO
610 "\" for random value (default)",
613 .set_default_value
= set_default_uuid_auto
,
616 /* --- support for array properties --- */
618 /* Used as an opaque for the object properties we add for each
619 * array element. Note that the struct Property must be first
620 * in the struct so that a pointer to this works as the opaque
621 * for the underlying element's property hooks as well as for
622 * our own release callback.
625 struct Property prop
;
627 ObjectPropertyRelease
*release
;
628 } ArrayElementProperty
;
630 /* object property release callback for array element properties:
631 * we call the underlying element's property release hook, and
632 * then free the memory we allocated when we added the property.
634 static void array_element_release(Object
*obj
, const char *name
, void *opaque
)
636 ArrayElementProperty
*p
= opaque
;
638 p
->release(obj
, name
, opaque
);
644 static void set_prop_arraylen(Object
*obj
, Visitor
*v
, const char *name
,
645 void *opaque
, Error
**errp
)
647 /* Setter for the property which defines the length of a
648 * variable-sized property array. As well as actually setting the
649 * array-length field in the device struct, we have to create the
650 * array itself and dynamically add the corresponding properties.
652 DeviceState
*dev
= DEVICE(obj
);
653 Property
*prop
= opaque
;
654 uint32_t *alenptr
= qdev_get_prop_ptr(dev
, prop
);
655 void **arrayptr
= (void *)dev
+ prop
->arrayoffset
;
657 const char *arrayname
;
661 qdev_prop_set_after_realize(dev
, name
, errp
);
665 error_setg(errp
, "array size property %s may not be set more than once",
669 if (!visit_type_uint32(v
, name
, alenptr
, errp
)) {
676 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
677 * strip it off so we can get the name of the array itself.
679 assert(strncmp(name
, PROP_ARRAY_LEN_PREFIX
,
680 strlen(PROP_ARRAY_LEN_PREFIX
)) == 0);
681 arrayname
= name
+ strlen(PROP_ARRAY_LEN_PREFIX
);
683 /* Note that it is the responsibility of the individual device's deinit
684 * to free the array proper.
686 *arrayptr
= eltptr
= g_malloc0(*alenptr
* prop
->arrayfieldsize
);
687 for (i
= 0; i
< *alenptr
; i
++, eltptr
+= prop
->arrayfieldsize
) {
688 char *propname
= g_strdup_printf("%s[%d]", arrayname
, i
);
689 ArrayElementProperty
*arrayprop
= g_new0(ArrayElementProperty
, 1);
690 arrayprop
->release
= prop
->arrayinfo
->release
;
691 arrayprop
->propname
= propname
;
692 arrayprop
->prop
.info
= prop
->arrayinfo
;
693 arrayprop
->prop
.name
= propname
;
694 /* This ugly piece of pointer arithmetic sets up the offset so
695 * that when the underlying get/set hooks call qdev_get_prop_ptr
696 * they get the right answer despite the array element not actually
697 * being inside the device struct.
699 arrayprop
->prop
.offset
= eltptr
- (void *)dev
;
700 assert(qdev_get_prop_ptr(dev
, &arrayprop
->prop
) == eltptr
);
701 object_property_add(obj
, propname
,
702 arrayprop
->prop
.info
->name
,
703 arrayprop
->prop
.info
->get
,
704 arrayprop
->prop
.info
->set
,
705 array_element_release
,
710 const PropertyInfo qdev_prop_arraylen
= {
713 .set
= set_prop_arraylen
,
714 .set_default_value
= qdev_propinfo_set_default_value_uint
,
717 /* --- public helpers --- */
719 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
724 while (props
->name
) {
725 if (strcmp(props
->name
, name
) == 0) {
733 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
738 /* device properties */
739 class = object_get_class(OBJECT(dev
));
741 prop
= qdev_prop_walk(DEVICE_CLASS(class)->props_
, name
);
745 class = object_class_get_parent(class);
746 } while (class != object_class_by_name(TYPE_DEVICE
));
751 void error_set_from_qdev_prop_error(Error
**errp
, int ret
, DeviceState
*dev
,
752 Property
*prop
, const char *value
)
756 error_setg(errp
, "Property '%s.%s' can't take value '%s', it's in use",
757 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
761 error_setg(errp
, QERR_PROPERTY_VALUE_BAD
,
762 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
765 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
766 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
773 void qdev_prop_set_bit(DeviceState
*dev
, const char *name
, bool value
)
775 object_property_set_bool(OBJECT(dev
), name
, value
, &error_abort
);
778 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
780 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
783 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
785 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
788 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
790 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
793 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
795 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
798 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
800 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
803 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, const char *value
)
805 object_property_set_str(OBJECT(dev
), name
, value
, &error_abort
);
808 void qdev_prop_set_enum(DeviceState
*dev
, const char *name
, int value
)
812 prop
= qdev_prop_find(dev
, name
);
813 object_property_set_str(OBJECT(dev
), name
,
814 qapi_enum_lookup(prop
->info
->enum_table
, value
),
818 static GPtrArray
*global_props(void)
820 static GPtrArray
*gp
;
823 gp
= g_ptr_array_new();
829 void qdev_prop_register_global(GlobalProperty
*prop
)
831 g_ptr_array_add(global_props(), prop
);
834 const GlobalProperty
*qdev_find_global_prop(DeviceState
*dev
,
837 GPtrArray
*props
= global_props();
838 const GlobalProperty
*p
;
841 for (i
= 0; i
< props
->len
; i
++) {
842 p
= g_ptr_array_index(props
, i
);
843 if (object_dynamic_cast(OBJECT(dev
), p
->driver
)
844 && !strcmp(p
->property
, name
)) {
851 int qdev_prop_check_globals(void)
855 for (i
= 0; i
< global_props()->len
; i
++) {
856 GlobalProperty
*prop
;
860 prop
= g_ptr_array_index(global_props(), i
);
864 oc
= object_class_by_name(prop
->driver
);
865 oc
= object_class_dynamic_cast(oc
, TYPE_DEVICE
);
867 warn_report("global %s.%s has invalid class name",
868 prop
->driver
, prop
->property
);
872 dc
= DEVICE_CLASS(oc
);
873 if (!dc
->hotpluggable
&& !prop
->used
) {
874 warn_report("global %s.%s=%s not used",
875 prop
->driver
, prop
->property
, prop
->value
);
883 void qdev_prop_set_globals(DeviceState
*dev
)
885 object_apply_global_props(OBJECT(dev
), global_props(),
886 dev
->hotplugged
? NULL
: &error_fatal
);
889 /* --- 64bit unsigned int 'size' type --- */
891 static void get_size(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
894 DeviceState
*dev
= DEVICE(obj
);
895 Property
*prop
= opaque
;
896 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
898 visit_type_size(v
, name
, ptr
, errp
);
901 static void set_size(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
904 DeviceState
*dev
= DEVICE(obj
);
905 Property
*prop
= opaque
;
906 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
908 visit_type_size(v
, name
, ptr
, errp
);
911 const PropertyInfo qdev_prop_size
= {
915 .set_default_value
= qdev_propinfo_set_default_value_uint
,
918 /* --- object link property --- */
920 static void create_link_property(ObjectClass
*oc
, Property
*prop
)
922 object_class_property_add_link(oc
, prop
->name
, prop
->link_type
,
924 qdev_prop_allow_set_link_before_realize
,
925 OBJ_PROP_LINK_STRONG
);
928 const PropertyInfo qdev_prop_link
= {
930 .create
= create_link_property
,