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