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"
9 #include "qemu/units.h"
10 #include "qemu/cutils.h"
11 #include "qdev-prop-internal.h"
13 void qdev_prop_set_after_realize(DeviceState
*dev
, const char *name
,
17 error_setg(errp
, "Attempt to set property '%s' on device '%s' "
18 "(type '%s') after it was realized", name
, dev
->id
,
19 object_get_typename(OBJECT(dev
)));
21 error_setg(errp
, "Attempt to set property '%s' on anonymous device "
22 "(type '%s') after it was realized", name
,
23 object_get_typename(OBJECT(dev
)));
27 void qdev_prop_allow_set_link_before_realize(const Object
*obj
,
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(Object
*obj
, Property
*prop
)
47 void qdev_propinfo_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
48 void *opaque
, Error
**errp
)
50 Property
*prop
= opaque
;
51 int *ptr
= qdev_get_prop_ptr(obj
, prop
);
53 visit_type_enum(v
, prop
->name
, ptr
, prop
->info
->enum_table
, errp
);
56 void qdev_propinfo_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
57 void *opaque
, Error
**errp
)
59 DeviceState
*dev
= DEVICE(obj
);
60 Property
*prop
= opaque
;
61 int *ptr
= qdev_get_prop_ptr(obj
, prop
);
64 qdev_prop_set_after_realize(dev
, name
, errp
);
68 visit_type_enum(v
, prop
->name
, ptr
, prop
->info
->enum_table
, errp
);
71 void qdev_propinfo_set_default_value_enum(ObjectProperty
*op
,
74 object_property_set_default_str(op
,
75 qapi_enum_lookup(prop
->info
->enum_table
, prop
->defval
.i
));
78 const PropertyInfo qdev_prop_enum
= {
80 .get
= qdev_propinfo_get_enum
,
81 .set
= qdev_propinfo_set_enum
,
82 .set_default_value
= qdev_propinfo_set_default_value_enum
,
87 static uint32_t qdev_get_prop_mask(Property
*prop
)
89 assert(prop
->info
== &qdev_prop_bit
);
90 return 0x1 << prop
->bitnr
;
93 static void bit_prop_set(Object
*obj
, Property
*props
, bool val
)
95 uint32_t *p
= qdev_get_prop_ptr(obj
, props
);
96 uint32_t mask
= qdev_get_prop_mask(props
);
104 static void prop_get_bit(Object
*obj
, Visitor
*v
, const char *name
,
105 void *opaque
, Error
**errp
)
107 Property
*prop
= opaque
;
108 uint32_t *p
= qdev_get_prop_ptr(obj
, 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
;
122 qdev_prop_set_after_realize(dev
, name
, errp
);
126 if (!visit_type_bool(v
, name
, &value
, errp
)) {
129 bit_prop_set(obj
, prop
, value
);
132 static void set_default_value_bool(ObjectProperty
*op
, const Property
*prop
)
134 object_property_set_default_bool(op
, prop
->defval
.u
);
137 const PropertyInfo qdev_prop_bit
= {
139 .description
= "on/off",
142 .set_default_value
= set_default_value_bool
,
147 static uint64_t qdev_get_prop_mask64(Property
*prop
)
149 assert(prop
->info
== &qdev_prop_bit64
);
150 return 0x1ull
<< prop
->bitnr
;
153 static void bit64_prop_set(Object
*obj
, Property
*props
, bool val
)
155 uint64_t *p
= qdev_get_prop_ptr(obj
, props
);
156 uint64_t mask
= qdev_get_prop_mask64(props
);
164 static void prop_get_bit64(Object
*obj
, Visitor
*v
, const char *name
,
165 void *opaque
, Error
**errp
)
167 Property
*prop
= opaque
;
168 uint64_t *p
= qdev_get_prop_ptr(obj
, prop
);
169 bool value
= (*p
& qdev_get_prop_mask64(prop
)) != 0;
171 visit_type_bool(v
, name
, &value
, errp
);
174 static void prop_set_bit64(Object
*obj
, Visitor
*v
, const char *name
,
175 void *opaque
, Error
**errp
)
177 DeviceState
*dev
= DEVICE(obj
);
178 Property
*prop
= opaque
;
182 qdev_prop_set_after_realize(dev
, name
, errp
);
186 if (!visit_type_bool(v
, name
, &value
, errp
)) {
189 bit64_prop_set(obj
, prop
, value
);
192 const PropertyInfo qdev_prop_bit64
= {
194 .description
= "on/off",
195 .get
= prop_get_bit64
,
196 .set
= prop_set_bit64
,
197 .set_default_value
= set_default_value_bool
,
202 static void get_bool(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
205 Property
*prop
= opaque
;
206 bool *ptr
= qdev_get_prop_ptr(obj
, prop
);
208 visit_type_bool(v
, name
, ptr
, errp
);
211 static void set_bool(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
214 DeviceState
*dev
= DEVICE(obj
);
215 Property
*prop
= opaque
;
216 bool *ptr
= qdev_get_prop_ptr(obj
, prop
);
219 qdev_prop_set_after_realize(dev
, name
, errp
);
223 visit_type_bool(v
, name
, ptr
, errp
);
226 const PropertyInfo qdev_prop_bool
= {
230 .set_default_value
= set_default_value_bool
,
233 /* --- 8bit integer --- */
235 static void get_uint8(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
238 Property
*prop
= opaque
;
239 uint8_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
241 visit_type_uint8(v
, name
, ptr
, errp
);
244 static void set_uint8(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
247 DeviceState
*dev
= DEVICE(obj
);
248 Property
*prop
= opaque
;
249 uint8_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
252 qdev_prop_set_after_realize(dev
, name
, errp
);
256 visit_type_uint8(v
, name
, ptr
, errp
);
259 void qdev_propinfo_set_default_value_int(ObjectProperty
*op
,
260 const Property
*prop
)
262 object_property_set_default_int(op
, prop
->defval
.i
);
265 void qdev_propinfo_set_default_value_uint(ObjectProperty
*op
,
266 const Property
*prop
)
268 object_property_set_default_uint(op
, prop
->defval
.u
);
271 const PropertyInfo qdev_prop_uint8
= {
275 .set_default_value
= qdev_propinfo_set_default_value_uint
,
278 /* --- 16bit integer --- */
280 static void get_uint16(Object
*obj
, Visitor
*v
, const char *name
,
281 void *opaque
, Error
**errp
)
283 Property
*prop
= opaque
;
284 uint16_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
286 visit_type_uint16(v
, name
, ptr
, errp
);
289 static void set_uint16(Object
*obj
, Visitor
*v
, const char *name
,
290 void *opaque
, Error
**errp
)
292 DeviceState
*dev
= DEVICE(obj
);
293 Property
*prop
= opaque
;
294 uint16_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
297 qdev_prop_set_after_realize(dev
, name
, errp
);
301 visit_type_uint16(v
, name
, ptr
, errp
);
304 const PropertyInfo qdev_prop_uint16
= {
308 .set_default_value
= qdev_propinfo_set_default_value_uint
,
311 /* --- 32bit integer --- */
313 static void get_uint32(Object
*obj
, Visitor
*v
, const char *name
,
314 void *opaque
, Error
**errp
)
316 Property
*prop
= opaque
;
317 uint32_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
319 visit_type_uint32(v
, name
, ptr
, errp
);
322 static void set_uint32(Object
*obj
, Visitor
*v
, const char *name
,
323 void *opaque
, Error
**errp
)
325 DeviceState
*dev
= DEVICE(obj
);
326 Property
*prop
= opaque
;
327 uint32_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
330 qdev_prop_set_after_realize(dev
, name
, errp
);
334 visit_type_uint32(v
, name
, ptr
, errp
);
337 void qdev_propinfo_get_int32(Object
*obj
, Visitor
*v
, const char *name
,
338 void *opaque
, Error
**errp
)
340 Property
*prop
= opaque
;
341 int32_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
343 visit_type_int32(v
, name
, ptr
, errp
);
346 static void set_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(obj
, prop
);
354 qdev_prop_set_after_realize(dev
, name
, errp
);
358 visit_type_int32(v
, name
, ptr
, errp
);
361 const PropertyInfo qdev_prop_uint32
= {
365 .set_default_value
= qdev_propinfo_set_default_value_uint
,
368 const PropertyInfo qdev_prop_int32
= {
370 .get
= qdev_propinfo_get_int32
,
372 .set_default_value
= qdev_propinfo_set_default_value_int
,
375 /* --- 64bit integer --- */
377 static void get_uint64(Object
*obj
, Visitor
*v
, const char *name
,
378 void *opaque
, Error
**errp
)
380 Property
*prop
= opaque
;
381 uint64_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
383 visit_type_uint64(v
, name
, ptr
, errp
);
386 static void set_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(obj
, prop
);
394 qdev_prop_set_after_realize(dev
, name
, errp
);
398 visit_type_uint64(v
, name
, ptr
, errp
);
401 static void get_int64(Object
*obj
, Visitor
*v
, const char *name
,
402 void *opaque
, Error
**errp
)
404 Property
*prop
= opaque
;
405 int64_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
407 visit_type_int64(v
, name
, ptr
, errp
);
410 static void set_int64(Object
*obj
, Visitor
*v
, const char *name
,
411 void *opaque
, Error
**errp
)
413 DeviceState
*dev
= DEVICE(obj
);
414 Property
*prop
= opaque
;
415 int64_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
418 qdev_prop_set_after_realize(dev
, name
, errp
);
422 visit_type_int64(v
, name
, ptr
, errp
);
425 const PropertyInfo qdev_prop_uint64
= {
429 .set_default_value
= qdev_propinfo_set_default_value_uint
,
432 const PropertyInfo qdev_prop_int64
= {
436 .set_default_value
= qdev_propinfo_set_default_value_int
,
441 static void release_string(Object
*obj
, const char *name
, void *opaque
)
443 Property
*prop
= opaque
;
444 g_free(*(char **)qdev_get_prop_ptr(obj
, prop
));
447 static void get_string(Object
*obj
, Visitor
*v
, const char *name
,
448 void *opaque
, Error
**errp
)
450 Property
*prop
= opaque
;
451 char **ptr
= qdev_get_prop_ptr(obj
, prop
);
454 char *str
= (char *)"";
455 visit_type_str(v
, name
, &str
, errp
);
457 visit_type_str(v
, name
, ptr
, errp
);
461 static void set_string(Object
*obj
, Visitor
*v
, const char *name
,
462 void *opaque
, Error
**errp
)
464 DeviceState
*dev
= DEVICE(obj
);
465 Property
*prop
= opaque
;
466 char **ptr
= qdev_get_prop_ptr(obj
, prop
);
470 qdev_prop_set_after_realize(dev
, name
, errp
);
474 if (!visit_type_str(v
, name
, &str
, errp
)) {
481 const PropertyInfo qdev_prop_string
= {
483 .release
= release_string
,
488 /* --- on/off/auto --- */
490 const PropertyInfo qdev_prop_on_off_auto
= {
492 .description
= "on/off/auto",
493 .enum_table
= &OnOffAuto_lookup
,
494 .get
= qdev_propinfo_get_enum
,
495 .set
= qdev_propinfo_set_enum
,
496 .set_default_value
= qdev_propinfo_set_default_value_enum
,
499 /* --- 32bit unsigned int 'size' type --- */
501 void qdev_propinfo_get_size32(Object
*obj
, Visitor
*v
, const char *name
,
502 void *opaque
, Error
**errp
)
504 Property
*prop
= opaque
;
505 uint32_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
506 uint64_t value
= *ptr
;
508 visit_type_size(v
, name
, &value
, errp
);
511 static void set_size32(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
514 DeviceState
*dev
= DEVICE(obj
);
515 Property
*prop
= opaque
;
516 uint32_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
520 qdev_prop_set_after_realize(dev
, name
, errp
);
524 if (!visit_type_size(v
, name
, &value
, errp
)) {
528 if (value
> UINT32_MAX
) {
530 "Property %s.%s doesn't take value %" PRIu64
532 object_get_typename(obj
), name
, value
, UINT32_MAX
);
539 const PropertyInfo qdev_prop_size32
= {
541 .get
= qdev_propinfo_get_size32
,
543 .set_default_value
= qdev_propinfo_set_default_value_uint
,
546 /* --- support for array properties --- */
548 /* Used as an opaque for the object properties we add for each
549 * array element. Note that the struct Property must be first
550 * in the struct so that a pointer to this works as the opaque
551 * for the underlying element's property hooks as well as for
552 * our own release callback.
555 struct Property prop
;
557 ObjectPropertyRelease
*release
;
558 } ArrayElementProperty
;
560 /* object property release callback for array element properties:
561 * we call the underlying element's property release hook, and
562 * then free the memory we allocated when we added the property.
564 static void array_element_release(Object
*obj
, const char *name
, void *opaque
)
566 ArrayElementProperty
*p
= opaque
;
568 p
->release(obj
, name
, opaque
);
574 static void set_prop_arraylen(Object
*obj
, Visitor
*v
, const char *name
,
575 void *opaque
, Error
**errp
)
577 /* Setter for the property which defines the length of a
578 * variable-sized property array. As well as actually setting the
579 * array-length field in the device struct, we have to create the
580 * array itself and dynamically add the corresponding properties.
582 DeviceState
*dev
= DEVICE(obj
);
583 Property
*prop
= opaque
;
584 uint32_t *alenptr
= qdev_get_prop_ptr(obj
, prop
);
585 void **arrayptr
= (void *)dev
+ prop
->arrayoffset
;
587 const char *arrayname
;
591 qdev_prop_set_after_realize(dev
, name
, errp
);
595 error_setg(errp
, "array size property %s may not be set more than once",
599 if (!visit_type_uint32(v
, name
, alenptr
, errp
)) {
606 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
607 * strip it off so we can get the name of the array itself.
609 assert(strncmp(name
, PROP_ARRAY_LEN_PREFIX
,
610 strlen(PROP_ARRAY_LEN_PREFIX
)) == 0);
611 arrayname
= name
+ strlen(PROP_ARRAY_LEN_PREFIX
);
613 /* Note that it is the responsibility of the individual device's deinit
614 * to free the array proper.
616 *arrayptr
= eltptr
= g_malloc0(*alenptr
* prop
->arrayfieldsize
);
617 for (i
= 0; i
< *alenptr
; i
++, eltptr
+= prop
->arrayfieldsize
) {
618 char *propname
= g_strdup_printf("%s[%d]", arrayname
, i
);
619 ArrayElementProperty
*arrayprop
= g_new0(ArrayElementProperty
, 1);
620 arrayprop
->release
= prop
->arrayinfo
->release
;
621 arrayprop
->propname
= propname
;
622 arrayprop
->prop
.info
= prop
->arrayinfo
;
623 arrayprop
->prop
.name
= propname
;
624 /* This ugly piece of pointer arithmetic sets up the offset so
625 * that when the underlying get/set hooks call qdev_get_prop_ptr
626 * they get the right answer despite the array element not actually
627 * being inside the device struct.
629 arrayprop
->prop
.offset
= eltptr
- (void *)dev
;
630 assert(qdev_get_prop_ptr(obj
, &arrayprop
->prop
) == eltptr
);
631 object_property_add(obj
, propname
,
632 arrayprop
->prop
.info
->name
,
633 arrayprop
->prop
.info
->get
,
634 arrayprop
->prop
.info
->set
,
635 array_element_release
,
640 const PropertyInfo qdev_prop_arraylen
= {
643 .set
= set_prop_arraylen
,
644 .set_default_value
= qdev_propinfo_set_default_value_uint
,
647 /* --- public helpers --- */
649 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
654 while (props
->name
) {
655 if (strcmp(props
->name
, name
) == 0) {
663 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
668 /* device properties */
669 class = object_get_class(OBJECT(dev
));
671 prop
= qdev_prop_walk(DEVICE_CLASS(class)->props_
, name
);
675 class = object_class_get_parent(class);
676 } while (class != object_class_by_name(TYPE_DEVICE
));
681 void error_set_from_qdev_prop_error(Error
**errp
, int ret
, Object
*obj
,
682 Property
*prop
, const char *value
)
686 error_setg(errp
, "Property '%s.%s' can't take value '%s', it's in use",
687 object_get_typename(obj
), prop
->name
, value
);
691 error_setg(errp
, QERR_PROPERTY_VALUE_BAD
,
692 object_get_typename(obj
), prop
->name
, value
);
695 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
696 object_get_typename(obj
), prop
->name
, value
);
703 void qdev_prop_set_bit(DeviceState
*dev
, const char *name
, bool value
)
705 object_property_set_bool(OBJECT(dev
), name
, value
, &error_abort
);
708 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
710 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
713 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
715 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
718 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
720 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
723 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
725 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
728 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
730 object_property_set_int(OBJECT(dev
), name
, value
, &error_abort
);
733 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, const char *value
)
735 object_property_set_str(OBJECT(dev
), name
, value
, &error_abort
);
738 void qdev_prop_set_enum(DeviceState
*dev
, const char *name
, int value
)
742 prop
= qdev_prop_find(dev
, name
);
743 object_property_set_str(OBJECT(dev
), name
,
744 qapi_enum_lookup(prop
->info
->enum_table
, value
),
748 static GPtrArray
*global_props(void)
750 static GPtrArray
*gp
;
753 gp
= g_ptr_array_new();
759 void qdev_prop_register_global(GlobalProperty
*prop
)
761 g_ptr_array_add(global_props(), prop
);
764 const GlobalProperty
*qdev_find_global_prop(Object
*obj
,
767 GPtrArray
*props
= global_props();
768 const GlobalProperty
*p
;
771 for (i
= 0; i
< props
->len
; i
++) {
772 p
= g_ptr_array_index(props
, i
);
773 if (object_dynamic_cast(obj
, p
->driver
)
774 && !strcmp(p
->property
, name
)) {
781 int qdev_prop_check_globals(void)
785 for (i
= 0; i
< global_props()->len
; i
++) {
786 GlobalProperty
*prop
;
790 prop
= g_ptr_array_index(global_props(), i
);
794 oc
= object_class_by_name(prop
->driver
);
795 oc
= object_class_dynamic_cast(oc
, TYPE_DEVICE
);
797 warn_report("global %s.%s has invalid class name",
798 prop
->driver
, prop
->property
);
802 dc
= DEVICE_CLASS(oc
);
803 if (!dc
->hotpluggable
&& !prop
->used
) {
804 warn_report("global %s.%s=%s not used",
805 prop
->driver
, prop
->property
, prop
->value
);
813 void qdev_prop_set_globals(DeviceState
*dev
)
815 object_apply_global_props(OBJECT(dev
), global_props(),
816 dev
->hotplugged
? NULL
: &error_fatal
);
819 /* --- 64bit unsigned int 'size' type --- */
821 static void get_size(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
824 Property
*prop
= opaque
;
825 uint64_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
827 visit_type_size(v
, name
, ptr
, errp
);
830 static void set_size(Object
*obj
, Visitor
*v
, const char *name
, void *opaque
,
833 DeviceState
*dev
= DEVICE(obj
);
834 Property
*prop
= opaque
;
835 uint64_t *ptr
= qdev_get_prop_ptr(obj
, prop
);
838 qdev_prop_set_after_realize(dev
, name
, errp
);
842 visit_type_size(v
, name
, ptr
, errp
);
845 const PropertyInfo qdev_prop_size
= {
849 .set_default_value
= qdev_propinfo_set_default_value_uint
,
852 /* --- object link property --- */
854 static void create_link_property(ObjectClass
*oc
, Property
*prop
)
856 object_class_property_add_link(oc
, prop
->name
, prop
->link_type
,
858 qdev_prop_allow_set_link_before_realize
,
859 OBJ_PROP_LINK_STRONG
);
862 const PropertyInfo qdev_prop_link
= {
864 .create
= create_link_property
,
867 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
)
869 Object
*obj
= OBJECT(dev
);
872 assert(!prop
->info
->create
);
874 op
= object_property_add(obj
, prop
->name
, prop
->info
->name
,
875 prop
->info
->get
, prop
->info
->set
,
879 object_property_set_description(obj
, prop
->name
,
880 prop
->info
->description
);
882 if (prop
->set_default
) {
883 prop
->info
->set_default_value(op
, prop
);
890 static void qdev_class_add_property(DeviceClass
*klass
, Property
*prop
)
892 ObjectClass
*oc
= OBJECT_CLASS(klass
);
894 if (prop
->info
->create
) {
895 prop
->info
->create(oc
, prop
);
899 op
= object_class_property_add(oc
,
900 prop
->name
, prop
->info
->name
,
901 prop
->info
->get
, prop
->info
->set
,
904 if (prop
->set_default
) {
905 prop
->info
->set_default_value(op
, prop
);
908 object_class_property_set_description(oc
, prop
->name
,
909 prop
->info
->description
);
913 * Legacy property handling
916 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
,
917 const char *name
, void *opaque
,
920 Property
*prop
= opaque
;
925 prop
->info
->print(obj
, prop
, buffer
, sizeof(buffer
));
926 visit_type_str(v
, name
, &ptr
, errp
);
930 * qdev_class_add_legacy_property:
931 * @dev: Device to add the property to.
932 * @prop: The qdev property definition.
934 * Add a legacy QOM property to @dev for qdev property @prop.
936 * Legacy properties are string versions of QOM properties. The format of
937 * the string depends on the property type. Legacy properties are only
938 * needed for "info qtree".
940 * Do not use this in new code! QOM Properties added through this interface
941 * will be given names in the "legacy" namespace.
943 static void qdev_class_add_legacy_property(DeviceClass
*dc
, Property
*prop
)
945 g_autofree
char *name
= NULL
;
947 /* Register pointer properties as legacy properties */
948 if (!prop
->info
->print
&& prop
->info
->get
) {
952 name
= g_strdup_printf("legacy-%s", prop
->name
);
953 object_class_property_add(OBJECT_CLASS(dc
), name
, "str",
954 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
958 void device_class_set_props(DeviceClass
*dc
, Property
*props
)
963 for (prop
= props
; prop
&& prop
->name
; prop
++) {
964 qdev_class_add_legacy_property(dc
, prop
);
965 qdev_class_add_property(dc
, prop
);
969 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
974 class = object_get_class(OBJECT(target
));
976 DeviceClass
*dc
= DEVICE_CLASS(class);
978 for (prop
= dc
->props_
; prop
&& prop
->name
; prop
++) {
979 object_property_add_alias(source
, prop
->name
,
980 OBJECT(target
), prop
->name
);
982 class = object_class_get_parent(class);
983 } while (class != object_class_by_name(TYPE_DEVICE
));