xref: /qemu/hw/core/qdev-properties.c (revision f917eed3) 
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"
12 
13 void qdev_prop_set_after_realize(DeviceState *dev, const char *name,
14                                   Error **errp)
15 {
16     if (dev->id) {
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)));
20     } else {
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)));
24     }
25 }
26 
27 void qdev_prop_allow_set_link_before_realize(const Object *obj,
28                                              const char *name,
29                                              Object *val, Error **errp)
30 {
31     DeviceState *dev = DEVICE(obj);
32 
33     if (dev->realized) {
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));
37     }
38 }
39 
40 void *qdev_get_prop_ptr(Object *obj, Property *prop)
41 {
42     void *ptr = obj;
43     ptr += prop->offset;
44     return ptr;
45 }
46 
47 void qdev_propinfo_get_enum(Object *obj, Visitor *v, const char *name,
48                             void *opaque, Error **errp)
49 {
50     Property *prop = opaque;
51     int *ptr = qdev_get_prop_ptr(obj, prop);
52 
53     visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp);
54 }
55 
56 void qdev_propinfo_set_enum(Object *obj, Visitor *v, const char *name,
57                             void *opaque, Error **errp)
58 {
59     DeviceState *dev = DEVICE(obj);
60     Property *prop = opaque;
61     int *ptr = qdev_get_prop_ptr(obj, prop);
62 
63     if (dev->realized) {
64         qdev_prop_set_after_realize(dev, name, errp);
65         return;
66     }
67 
68     visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp);
69 }
70 
71 void qdev_propinfo_set_default_value_enum(ObjectProperty *op,
72                                           const Property *prop)
73 {
74     object_property_set_default_str(op,
75         qapi_enum_lookup(prop->info->enum_table, prop->defval.i));
76 }
77 
78 const PropertyInfo qdev_prop_enum = {
79     .name  = "enum",
80     .get   = qdev_propinfo_get_enum,
81     .set   = qdev_propinfo_set_enum,
82     .set_default_value = qdev_propinfo_set_default_value_enum,
83 };
84 
85 /* Bit */
86 
87 static uint32_t qdev_get_prop_mask(Property *prop)
88 {
89     assert(prop->info == &qdev_prop_bit);
90     return 0x1 << prop->bitnr;
91 }
92 
93 static void bit_prop_set(Object *obj, Property *props, bool val)
94 {
95     uint32_t *p = qdev_get_prop_ptr(obj, props);
96     uint32_t mask = qdev_get_prop_mask(props);
97     if (val) {
98         *p |= mask;
99     } else {
100         *p &= ~mask;
101     }
102 }
103 
104 static void prop_get_bit(Object *obj, Visitor *v, const char *name,
105                          void *opaque, Error **errp)
106 {
107     Property *prop = opaque;
108     uint32_t *p = qdev_get_prop_ptr(obj, prop);
109     bool value = (*p & qdev_get_prop_mask(prop)) != 0;
110 
111     visit_type_bool(v, name, &value, errp);
112 }
113 
114 static void prop_set_bit(Object *obj, Visitor *v, const char *name,
115                          void *opaque, Error **errp)
116 {
117     DeviceState *dev = DEVICE(obj);
118     Property *prop = opaque;
119     bool value;
120 
121     if (dev->realized) {
122         qdev_prop_set_after_realize(dev, name, errp);
123         return;
124     }
125 
126     if (!visit_type_bool(v, name, &value, errp)) {
127         return;
128     }
129     bit_prop_set(obj, prop, value);
130 }
131 
132 static void set_default_value_bool(ObjectProperty *op, const Property *prop)
133 {
134     object_property_set_default_bool(op, prop->defval.u);
135 }
136 
137 const PropertyInfo qdev_prop_bit = {
138     .name  = "bool",
139     .description = "on/off",
140     .get   = prop_get_bit,
141     .set   = prop_set_bit,
142     .set_default_value = set_default_value_bool,
143 };
144 
145 /* Bit64 */
146 
147 static uint64_t qdev_get_prop_mask64(Property *prop)
148 {
149     assert(prop->info == &qdev_prop_bit64);
150     return 0x1ull << prop->bitnr;
151 }
152 
153 static void bit64_prop_set(Object *obj, Property *props, bool val)
154 {
155     uint64_t *p = qdev_get_prop_ptr(obj, props);
156     uint64_t mask = qdev_get_prop_mask64(props);
157     if (val) {
158         *p |= mask;
159     } else {
160         *p &= ~mask;
161     }
162 }
163 
164 static void prop_get_bit64(Object *obj, Visitor *v, const char *name,
165                            void *opaque, Error **errp)
166 {
167     Property *prop = opaque;
168     uint64_t *p = qdev_get_prop_ptr(obj, prop);
169     bool value = (*p & qdev_get_prop_mask64(prop)) != 0;
170 
171     visit_type_bool(v, name, &value, errp);
172 }
173 
174 static void prop_set_bit64(Object *obj, Visitor *v, const char *name,
175                            void *opaque, Error **errp)
176 {
177     DeviceState *dev = DEVICE(obj);
178     Property *prop = opaque;
179     bool value;
180 
181     if (dev->realized) {
182         qdev_prop_set_after_realize(dev, name, errp);
183         return;
184     }
185 
186     if (!visit_type_bool(v, name, &value, errp)) {
187         return;
188     }
189     bit64_prop_set(obj, prop, value);
190 }
191 
192 const PropertyInfo qdev_prop_bit64 = {
193     .name  = "bool",
194     .description = "on/off",
195     .get   = prop_get_bit64,
196     .set   = prop_set_bit64,
197     .set_default_value = set_default_value_bool,
198 };
199 
200 /* --- bool --- */
201 
202 static void get_bool(Object *obj, Visitor *v, const char *name, void *opaque,
203                      Error **errp)
204 {
205     Property *prop = opaque;
206     bool *ptr = qdev_get_prop_ptr(obj, prop);
207 
208     visit_type_bool(v, name, ptr, errp);
209 }
210 
211 static void set_bool(Object *obj, Visitor *v, const char *name, void *opaque,
212                      Error **errp)
213 {
214     DeviceState *dev = DEVICE(obj);
215     Property *prop = opaque;
216     bool *ptr = qdev_get_prop_ptr(obj, prop);
217 
218     if (dev->realized) {
219         qdev_prop_set_after_realize(dev, name, errp);
220         return;
221     }
222 
223     visit_type_bool(v, name, ptr, errp);
224 }
225 
226 const PropertyInfo qdev_prop_bool = {
227     .name  = "bool",
228     .get   = get_bool,
229     .set   = set_bool,
230     .set_default_value = set_default_value_bool,
231 };
232 
233 /* --- 8bit integer --- */
234 
235 static void get_uint8(Object *obj, Visitor *v, const char *name, void *opaque,
236                       Error **errp)
237 {
238     Property *prop = opaque;
239     uint8_t *ptr = qdev_get_prop_ptr(obj, prop);
240 
241     visit_type_uint8(v, name, ptr, errp);
242 }
243 
244 static void set_uint8(Object *obj, Visitor *v, const char *name, void *opaque,
245                       Error **errp)
246 {
247     DeviceState *dev = DEVICE(obj);
248     Property *prop = opaque;
249     uint8_t *ptr = qdev_get_prop_ptr(obj, prop);
250 
251     if (dev->realized) {
252         qdev_prop_set_after_realize(dev, name, errp);
253         return;
254     }
255 
256     visit_type_uint8(v, name, ptr, errp);
257 }
258 
259 void qdev_propinfo_set_default_value_int(ObjectProperty *op,
260                                          const Property *prop)
261 {
262     object_property_set_default_int(op, prop->defval.i);
263 }
264 
265 void qdev_propinfo_set_default_value_uint(ObjectProperty *op,
266                                           const Property *prop)
267 {
268     object_property_set_default_uint(op, prop->defval.u);
269 }
270 
271 const PropertyInfo qdev_prop_uint8 = {
272     .name  = "uint8",
273     .get   = get_uint8,
274     .set   = set_uint8,
275     .set_default_value = qdev_propinfo_set_default_value_uint,
276 };
277 
278 /* --- 16bit integer --- */
279 
280 static void get_uint16(Object *obj, Visitor *v, const char *name,
281                        void *opaque, Error **errp)
282 {
283     Property *prop = opaque;
284     uint16_t *ptr = qdev_get_prop_ptr(obj, prop);
285 
286     visit_type_uint16(v, name, ptr, errp);
287 }
288 
289 static void set_uint16(Object *obj, Visitor *v, const char *name,
290                        void *opaque, Error **errp)
291 {
292     DeviceState *dev = DEVICE(obj);
293     Property *prop = opaque;
294     uint16_t *ptr = qdev_get_prop_ptr(obj, prop);
295 
296     if (dev->realized) {
297         qdev_prop_set_after_realize(dev, name, errp);
298         return;
299     }
300 
301     visit_type_uint16(v, name, ptr, errp);
302 }
303 
304 const PropertyInfo qdev_prop_uint16 = {
305     .name  = "uint16",
306     .get   = get_uint16,
307     .set   = set_uint16,
308     .set_default_value = qdev_propinfo_set_default_value_uint,
309 };
310 
311 /* --- 32bit integer --- */
312 
313 static void get_uint32(Object *obj, Visitor *v, const char *name,
314                        void *opaque, Error **errp)
315 {
316     Property *prop = opaque;
317     uint32_t *ptr = qdev_get_prop_ptr(obj, prop);
318 
319     visit_type_uint32(v, name, ptr, errp);
320 }
321 
322 static void set_uint32(Object *obj, Visitor *v, const char *name,
323                        void *opaque, Error **errp)
324 {
325     DeviceState *dev = DEVICE(obj);
326     Property *prop = opaque;
327     uint32_t *ptr = qdev_get_prop_ptr(obj, prop);
328 
329     if (dev->realized) {
330         qdev_prop_set_after_realize(dev, name, errp);
331         return;
332     }
333 
334     visit_type_uint32(v, name, ptr, errp);
335 }
336 
337 void qdev_propinfo_get_int32(Object *obj, Visitor *v, const char *name,
338                              void *opaque, Error **errp)
339 {
340     Property *prop = opaque;
341     int32_t *ptr = qdev_get_prop_ptr(obj, prop);
342 
343     visit_type_int32(v, name, ptr, errp);
344 }
345 
346 static void set_int32(Object *obj, Visitor *v, const char *name, void *opaque,
347                       Error **errp)
348 {
349     DeviceState *dev = DEVICE(obj);
350     Property *prop = opaque;
351     int32_t *ptr = qdev_get_prop_ptr(obj, prop);
352 
353     if (dev->realized) {
354         qdev_prop_set_after_realize(dev, name, errp);
355         return;
356     }
357 
358     visit_type_int32(v, name, ptr, errp);
359 }
360 
361 const PropertyInfo qdev_prop_uint32 = {
362     .name  = "uint32",
363     .get   = get_uint32,
364     .set   = set_uint32,
365     .set_default_value = qdev_propinfo_set_default_value_uint,
366 };
367 
368 const PropertyInfo qdev_prop_int32 = {
369     .name  = "int32",
370     .get   = qdev_propinfo_get_int32,
371     .set   = set_int32,
372     .set_default_value = qdev_propinfo_set_default_value_int,
373 };
374 
375 /* --- 64bit integer --- */
376 
377 static void get_uint64(Object *obj, Visitor *v, const char *name,
378                        void *opaque, Error **errp)
379 {
380     Property *prop = opaque;
381     uint64_t *ptr = qdev_get_prop_ptr(obj, prop);
382 
383     visit_type_uint64(v, name, ptr, errp);
384 }
385 
386 static void set_uint64(Object *obj, Visitor *v, const char *name,
387                        void *opaque, Error **errp)
388 {
389     DeviceState *dev = DEVICE(obj);
390     Property *prop = opaque;
391     uint64_t *ptr = qdev_get_prop_ptr(obj, prop);
392 
393     if (dev->realized) {
394         qdev_prop_set_after_realize(dev, name, errp);
395         return;
396     }
397 
398     visit_type_uint64(v, name, ptr, errp);
399 }
400 
401 static void get_int64(Object *obj, Visitor *v, const char *name,
402                       void *opaque, Error **errp)
403 {
404     Property *prop = opaque;
405     int64_t *ptr = qdev_get_prop_ptr(obj, prop);
406 
407     visit_type_int64(v, name, ptr, errp);
408 }
409 
410 static void set_int64(Object *obj, Visitor *v, const char *name,
411                       void *opaque, Error **errp)
412 {
413     DeviceState *dev = DEVICE(obj);
414     Property *prop = opaque;
415     int64_t *ptr = qdev_get_prop_ptr(obj, prop);
416 
417     if (dev->realized) {
418         qdev_prop_set_after_realize(dev, name, errp);
419         return;
420     }
421 
422     visit_type_int64(v, name, ptr, errp);
423 }
424 
425 const PropertyInfo qdev_prop_uint64 = {
426     .name  = "uint64",
427     .get   = get_uint64,
428     .set   = set_uint64,
429     .set_default_value = qdev_propinfo_set_default_value_uint,
430 };
431 
432 const PropertyInfo qdev_prop_int64 = {
433     .name  = "int64",
434     .get   = get_int64,
435     .set   = set_int64,
436     .set_default_value = qdev_propinfo_set_default_value_int,
437 };
438 
439 /* --- string --- */
440 
441 static void release_string(Object *obj, const char *name, void *opaque)
442 {
443     Property *prop = opaque;
444     g_free(*(char **)qdev_get_prop_ptr(obj, prop));
445 }
446 
447 static void get_string(Object *obj, Visitor *v, const char *name,
448                        void *opaque, Error **errp)
449 {
450     Property *prop = opaque;
451     char **ptr = qdev_get_prop_ptr(obj, prop);
452 
453     if (!*ptr) {
454         char *str = (char *)"";
455         visit_type_str(v, name, &str, errp);
456     } else {
457         visit_type_str(v, name, ptr, errp);
458     }
459 }
460 
461 static void set_string(Object *obj, Visitor *v, const char *name,
462                        void *opaque, Error **errp)
463 {
464     DeviceState *dev = DEVICE(obj);
465     Property *prop = opaque;
466     char **ptr = qdev_get_prop_ptr(obj, prop);
467     char *str;
468 
469     if (dev->realized) {
470         qdev_prop_set_after_realize(dev, name, errp);
471         return;
472     }
473 
474     if (!visit_type_str(v, name, &str, errp)) {
475         return;
476     }
477     g_free(*ptr);
478     *ptr = str;
479 }
480 
481 const PropertyInfo qdev_prop_string = {
482     .name  = "str",
483     .release = release_string,
484     .get   = get_string,
485     .set   = set_string,
486 };
487 
488 /* --- on/off/auto --- */
489 
490 const PropertyInfo qdev_prop_on_off_auto = {
491     .name = "OnOffAuto",
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,
497 };
498 
499 /* --- 32bit unsigned int 'size' type --- */
500 
501 void qdev_propinfo_get_size32(Object *obj, Visitor *v, const char *name,
502                               void *opaque, Error **errp)
503 {
504     Property *prop = opaque;
505     uint32_t *ptr = qdev_get_prop_ptr(obj, prop);
506     uint64_t value = *ptr;
507 
508     visit_type_size(v, name, &value, errp);
509 }
510 
511 static void set_size32(Object *obj, Visitor *v, const char *name, void *opaque,
512                        Error **errp)
513 {
514     DeviceState *dev = DEVICE(obj);
515     Property *prop = opaque;
516     uint32_t *ptr = qdev_get_prop_ptr(obj, prop);
517     uint64_t value;
518 
519     if (dev->realized) {
520         qdev_prop_set_after_realize(dev, name, errp);
521         return;
522     }
523 
524     if (!visit_type_size(v, name, &value, errp)) {
525         return;
526     }
527 
528     if (value > UINT32_MAX) {
529         error_setg(errp,
530                    "Property %s.%s doesn't take value %" PRIu64
531                    " (maximum: %u)",
532                    object_get_typename(obj), name, value, UINT32_MAX);
533         return;
534     }
535 
536     *ptr = value;
537 }
538 
539 const PropertyInfo qdev_prop_size32 = {
540     .name  = "size",
541     .get = qdev_propinfo_get_size32,
542     .set = set_size32,
543     .set_default_value = qdev_propinfo_set_default_value_uint,
544 };
545 
546 /* --- support for array properties --- */
547 
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.
553  */
554 typedef struct {
555     struct Property prop;
556     char *propname;
557     ObjectPropertyRelease *release;
558 } ArrayElementProperty;
559 
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.
563  */
564 static void array_element_release(Object *obj, const char *name, void *opaque)
565 {
566     ArrayElementProperty *p = opaque;
567     if (p->release) {
568         p->release(obj, name, opaque);
569     }
570     g_free(p->propname);
571     g_free(p);
572 }
573 
574 static void set_prop_arraylen(Object *obj, Visitor *v, const char *name,
575                               void *opaque, Error **errp)
576 {
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.
581      */
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;
586     void *eltptr;
587     const char *arrayname;
588     int i;
589 
590     if (dev->realized) {
591         qdev_prop_set_after_realize(dev, name, errp);
592         return;
593     }
594     if (*alenptr) {
595         error_setg(errp, "array size property %s may not be set more than once",
596                    name);
597         return;
598     }
599     if (!visit_type_uint32(v, name, alenptr, errp)) {
600         return;
601     }
602     if (!*alenptr) {
603         return;
604     }
605 
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.
608      */
609     assert(strncmp(name, PROP_ARRAY_LEN_PREFIX,
610                    strlen(PROP_ARRAY_LEN_PREFIX)) == 0);
611     arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX);
612 
613     /* Note that it is the responsibility of the individual device's deinit
614      * to free the array proper.
615      */
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.
628          */
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,
636                             arrayprop);
637     }
638 }
639 
640 const PropertyInfo qdev_prop_arraylen = {
641     .name = "uint32",
642     .get = get_uint32,
643     .set = set_prop_arraylen,
644     .set_default_value = qdev_propinfo_set_default_value_uint,
645 };
646 
647 /* --- public helpers --- */
648 
649 static Property *qdev_prop_walk(Property *props, const char *name)
650 {
651     if (!props) {
652         return NULL;
653     }
654     while (props->name) {
655         if (strcmp(props->name, name) == 0) {
656             return props;
657         }
658         props++;
659     }
660     return NULL;
661 }
662 
663 static Property *qdev_prop_find(DeviceState *dev, const char *name)
664 {
665     ObjectClass *class;
666     Property *prop;
667 
668     /* device properties */
669     class = object_get_class(OBJECT(dev));
670     do {
671         prop = qdev_prop_walk(DEVICE_CLASS(class)->props_, name);
672         if (prop) {
673             return prop;
674         }
675         class = object_class_get_parent(class);
676     } while (class != object_class_by_name(TYPE_DEVICE));
677 
678     return NULL;
679 }
680 
681 void error_set_from_qdev_prop_error(Error **errp, int ret, Object *obj,
682                                     Property *prop, const char *value)
683 {
684     switch (ret) {
685     case -EEXIST:
686         error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use",
687                   object_get_typename(obj), prop->name, value);
688         break;
689     default:
690     case -EINVAL:
691         error_setg(errp, QERR_PROPERTY_VALUE_BAD,
692                    object_get_typename(obj), prop->name, value);
693         break;
694     case -ENOENT:
695         error_setg(errp, "Property '%s.%s' can't find value '%s'",
696                   object_get_typename(obj), prop->name, value);
697         break;
698     case 0:
699         break;
700     }
701 }
702 
703 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
704 {
705     object_property_set_bool(OBJECT(dev), name, value, &error_abort);
706 }
707 
708 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
709 {
710     object_property_set_int(OBJECT(dev), name, value, &error_abort);
711 }
712 
713 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
714 {
715     object_property_set_int(OBJECT(dev), name, value, &error_abort);
716 }
717 
718 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
719 {
720     object_property_set_int(OBJECT(dev), name, value, &error_abort);
721 }
722 
723 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
724 {
725     object_property_set_int(OBJECT(dev), name, value, &error_abort);
726 }
727 
728 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
729 {
730     object_property_set_int(OBJECT(dev), name, value, &error_abort);
731 }
732 
733 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value)
734 {
735     object_property_set_str(OBJECT(dev), name, value, &error_abort);
736 }
737 
738 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
739 {
740     Property *prop;
741 
742     prop = qdev_prop_find(dev, name);
743     object_property_set_str(OBJECT(dev), name,
744                             qapi_enum_lookup(prop->info->enum_table, value),
745                             &error_abort);
746 }
747 
748 static GPtrArray *global_props(void)
749 {
750     static GPtrArray *gp;
751 
752     if (!gp) {
753         gp = g_ptr_array_new();
754     }
755 
756     return gp;
757 }
758 
759 void qdev_prop_register_global(GlobalProperty *prop)
760 {
761     g_ptr_array_add(global_props(), prop);
762 }
763 
764 const GlobalProperty *qdev_find_global_prop(Object *obj,
765                                             const char *name)
766 {
767     GPtrArray *props = global_props();
768     const GlobalProperty *p;
769     int i;
770 
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)) {
775             return p;
776         }
777     }
778     return NULL;
779 }
780 
781 int qdev_prop_check_globals(void)
782 {
783     int i, ret = 0;
784 
785     for (i = 0; i < global_props()->len; i++) {
786         GlobalProperty *prop;
787         ObjectClass *oc;
788         DeviceClass *dc;
789 
790         prop = g_ptr_array_index(global_props(), i);
791         if (prop->used) {
792             continue;
793         }
794         oc = object_class_by_name(prop->driver);
795         oc = object_class_dynamic_cast(oc, TYPE_DEVICE);
796         if (!oc) {
797             warn_report("global %s.%s has invalid class name",
798                         prop->driver, prop->property);
799             ret = 1;
800             continue;
801         }
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);
806             ret = 1;
807             continue;
808         }
809     }
810     return ret;
811 }
812 
813 void qdev_prop_set_globals(DeviceState *dev)
814 {
815     object_apply_global_props(OBJECT(dev), global_props(),
816                               dev->hotplugged ? NULL : &error_fatal);
817 }
818 
819 /* --- 64bit unsigned int 'size' type --- */
820 
821 static void get_size(Object *obj, Visitor *v, const char *name, void *opaque,
822                      Error **errp)
823 {
824     Property *prop = opaque;
825     uint64_t *ptr = qdev_get_prop_ptr(obj, prop);
826 
827     visit_type_size(v, name, ptr, errp);
828 }
829 
830 static void set_size(Object *obj, Visitor *v, const char *name, void *opaque,
831                      Error **errp)
832 {
833     DeviceState *dev = DEVICE(obj);
834     Property *prop = opaque;
835     uint64_t *ptr = qdev_get_prop_ptr(obj, prop);
836 
837     if (dev->realized) {
838         qdev_prop_set_after_realize(dev, name, errp);
839         return;
840     }
841 
842     visit_type_size(v, name, ptr, errp);
843 }
844 
845 const PropertyInfo qdev_prop_size = {
846     .name  = "size",
847     .get = get_size,
848     .set = set_size,
849     .set_default_value = qdev_propinfo_set_default_value_uint,
850 };
851 
852 /* --- object link property --- */
853 
854 static void create_link_property(ObjectClass *oc, Property *prop)
855 {
856     object_class_property_add_link(oc, prop->name, prop->link_type,
857                                    prop->offset,
858                                    qdev_prop_allow_set_link_before_realize,
859                                    OBJ_PROP_LINK_STRONG);
860 }
861 
862 const PropertyInfo qdev_prop_link = {
863     .name = "link",
864     .create = create_link_property,
865 };
866 
867 void qdev_property_add_static(DeviceState *dev, Property *prop)
868 {
869     Object *obj = OBJECT(dev);
870     ObjectProperty *op;
871 
872     assert(!prop->info->create);
873 
874     op = object_property_add(obj, prop->name, prop->info->name,
875                              prop->info->get, prop->info->set,
876                              prop->info->release,
877                              prop);
878 
879     object_property_set_description(obj, prop->name,
880                                     prop->info->description);
881 
882     if (prop->set_default) {
883         prop->info->set_default_value(op, prop);
884         if (op->init) {
885             op->init(obj, op);
886         }
887     }
888 }
889 
890 static void qdev_class_add_property(DeviceClass *klass, Property *prop)
891 {
892     ObjectClass *oc = OBJECT_CLASS(klass);
893 
894     if (prop->info->create) {
895         prop->info->create(oc, prop);
896     } else {
897         ObjectProperty *op;
898 
899         op = object_class_property_add(oc,
900                                        prop->name, prop->info->name,
901                                        prop->info->get, prop->info->set,
902                                        prop->info->release,
903                                        prop);
904         if (prop->set_default) {
905             prop->info->set_default_value(op, prop);
906         }
907     }
908     object_class_property_set_description(oc, prop->name,
909                                           prop->info->description);
910 }
911 
912 /**
913  * Legacy property handling
914  */
915 
916 static void qdev_get_legacy_property(Object *obj, Visitor *v,
917                                      const char *name, void *opaque,
918                                      Error **errp)
919 {
920     Property *prop = opaque;
921 
922     char buffer[1024];
923     char *ptr = buffer;
924 
925     prop->info->print(obj, prop, buffer, sizeof(buffer));
926     visit_type_str(v, name, &ptr, errp);
927 }
928 
929 /**
930  * qdev_class_add_legacy_property:
931  * @dev: Device to add the property to.
932  * @prop: The qdev property definition.
933  *
934  * Add a legacy QOM property to @dev for qdev property @prop.
935  *
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".
939  *
940  * Do not use this in new code!  QOM Properties added through this interface
941  * will be given names in the "legacy" namespace.
942  */
943 static void qdev_class_add_legacy_property(DeviceClass *dc, Property *prop)
944 {
945     g_autofree char *name = NULL;
946 
947     /* Register pointer properties as legacy properties */
948     if (!prop->info->print && prop->info->get) {
949         return;
950     }
951 
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,
955         NULL, NULL, prop);
956 }
957 
958 void device_class_set_props(DeviceClass *dc, Property *props)
959 {
960     Property *prop;
961 
962     dc->props_ = props;
963     for (prop = props; prop && prop->name; prop++) {
964         qdev_class_add_legacy_property(dc, prop);
965         qdev_class_add_property(dc, prop);
966     }
967 }
968 
969 void qdev_alias_all_properties(DeviceState *target, Object *source)
970 {
971     ObjectClass *class;
972     Property *prop;
973 
974     class = object_get_class(OBJECT(target));
975     do {
976         DeviceClass *dc = DEVICE_CLASS(class);
977 
978         for (prop = dc->props_; prop && prop->name; prop++) {
979             object_property_add_alias(source, prop->name,
980                                       OBJECT(target), prop->name);
981         }
982         class = object_class_get_parent(class);
983     } while (class != object_class_by_name(TYPE_DEVICE));
984 }
985