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