qom: Add check() argument to object_property_add_link()
[qemu.git] / hw / core / qdev-properties.c
1 #include "net/net.h"
2 #include "hw/qdev.h"
3 #include "qapi/qmp/qerror.h"
4 #include "sysemu/blockdev.h"
5 #include "hw/block/block.h"
6 #include "net/hub.h"
7 #include "qapi/visitor.h"
8 #include "sysemu/char.h"
9
10 void qdev_prop_set_after_realize(DeviceState *dev, const char *name,
11 Error **errp)
12 {
13 if (dev->id) {
14 error_setg(errp, "Attempt to set property '%s' on device '%s' "
15 "(type '%s') after it was realized", name, dev->id,
16 object_get_typename(OBJECT(dev)));
17 } else {
18 error_setg(errp, "Attempt to set property '%s' on anonymous device "
19 "(type '%s') after it was realized", name,
20 object_get_typename(OBJECT(dev)));
21 }
22 }
23
24 void qdev_prop_allow_set_link_before_realize(Object *obj, const char *name,
25 Object *val, Error **errp)
26 {
27 DeviceState *dev = DEVICE(obj);
28
29 if (dev->realized) {
30 error_setg(errp, "Attempt to set link property '%s' on device '%s' "
31 "(type '%s') after it was realized",
32 name, dev->id, object_get_typename(obj));
33 }
34 }
35
36 void *qdev_get_prop_ptr(DeviceState *dev, Property *prop)
37 {
38 void *ptr = dev;
39 ptr += prop->offset;
40 return ptr;
41 }
42
43 static void get_enum(Object *obj, Visitor *v, void *opaque,
44 const char *name, Error **errp)
45 {
46 DeviceState *dev = DEVICE(obj);
47 Property *prop = opaque;
48 int *ptr = qdev_get_prop_ptr(dev, prop);
49
50 visit_type_enum(v, ptr, prop->info->enum_table,
51 prop->info->name, prop->name, errp);
52 }
53
54 static void set_enum(Object *obj, Visitor *v, void *opaque,
55 const char *name, Error **errp)
56 {
57 DeviceState *dev = DEVICE(obj);
58 Property *prop = opaque;
59 int *ptr = qdev_get_prop_ptr(dev, prop);
60
61 if (dev->realized) {
62 qdev_prop_set_after_realize(dev, name, errp);
63 return;
64 }
65
66 visit_type_enum(v, ptr, prop->info->enum_table,
67 prop->info->name, prop->name, errp);
68 }
69
70 /* Bit */
71
72 static uint32_t qdev_get_prop_mask(Property *prop)
73 {
74 assert(prop->info == &qdev_prop_bit);
75 return 0x1 << prop->bitnr;
76 }
77
78 static void bit_prop_set(DeviceState *dev, Property *props, bool val)
79 {
80 uint32_t *p = qdev_get_prop_ptr(dev, props);
81 uint32_t mask = qdev_get_prop_mask(props);
82 if (val) {
83 *p |= mask;
84 } else {
85 *p &= ~mask;
86 }
87 }
88
89 static void prop_get_bit(Object *obj, Visitor *v, void *opaque,
90 const char *name, Error **errp)
91 {
92 DeviceState *dev = DEVICE(obj);
93 Property *prop = opaque;
94 uint32_t *p = qdev_get_prop_ptr(dev, prop);
95 bool value = (*p & qdev_get_prop_mask(prop)) != 0;
96
97 visit_type_bool(v, &value, name, errp);
98 }
99
100 static void prop_set_bit(Object *obj, Visitor *v, void *opaque,
101 const char *name, Error **errp)
102 {
103 DeviceState *dev = DEVICE(obj);
104 Property *prop = opaque;
105 Error *local_err = NULL;
106 bool value;
107
108 if (dev->realized) {
109 qdev_prop_set_after_realize(dev, name, errp);
110 return;
111 }
112
113 visit_type_bool(v, &value, name, &local_err);
114 if (local_err) {
115 error_propagate(errp, local_err);
116 return;
117 }
118 bit_prop_set(dev, prop, value);
119 }
120
121 PropertyInfo qdev_prop_bit = {
122 .name = "bool",
123 .legacy_name = "on/off",
124 .get = prop_get_bit,
125 .set = prop_set_bit,
126 };
127
128 /* --- bool --- */
129
130 static void get_bool(Object *obj, Visitor *v, void *opaque,
131 const char *name, Error **errp)
132 {
133 DeviceState *dev = DEVICE(obj);
134 Property *prop = opaque;
135 bool *ptr = qdev_get_prop_ptr(dev, prop);
136
137 visit_type_bool(v, ptr, name, errp);
138 }
139
140 static void set_bool(Object *obj, Visitor *v, void *opaque,
141 const char *name, Error **errp)
142 {
143 DeviceState *dev = DEVICE(obj);
144 Property *prop = opaque;
145 bool *ptr = qdev_get_prop_ptr(dev, prop);
146
147 if (dev->realized) {
148 qdev_prop_set_after_realize(dev, name, errp);
149 return;
150 }
151
152 visit_type_bool(v, ptr, name, errp);
153 }
154
155 PropertyInfo qdev_prop_bool = {
156 .name = "bool",
157 .get = get_bool,
158 .set = set_bool,
159 };
160
161 /* --- 8bit integer --- */
162
163 static void get_uint8(Object *obj, Visitor *v, void *opaque,
164 const char *name, Error **errp)
165 {
166 DeviceState *dev = DEVICE(obj);
167 Property *prop = opaque;
168 uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
169
170 visit_type_uint8(v, ptr, name, errp);
171 }
172
173 static void set_uint8(Object *obj, Visitor *v, void *opaque,
174 const char *name, Error **errp)
175 {
176 DeviceState *dev = DEVICE(obj);
177 Property *prop = opaque;
178 uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
179
180 if (dev->realized) {
181 qdev_prop_set_after_realize(dev, name, errp);
182 return;
183 }
184
185 visit_type_uint8(v, ptr, name, errp);
186 }
187
188 PropertyInfo qdev_prop_uint8 = {
189 .name = "uint8",
190 .get = get_uint8,
191 .set = set_uint8,
192 };
193
194 /* --- 16bit integer --- */
195
196 static void get_uint16(Object *obj, Visitor *v, void *opaque,
197 const char *name, Error **errp)
198 {
199 DeviceState *dev = DEVICE(obj);
200 Property *prop = opaque;
201 uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
202
203 visit_type_uint16(v, ptr, name, errp);
204 }
205
206 static void set_uint16(Object *obj, Visitor *v, void *opaque,
207 const char *name, Error **errp)
208 {
209 DeviceState *dev = DEVICE(obj);
210 Property *prop = opaque;
211 uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
212
213 if (dev->realized) {
214 qdev_prop_set_after_realize(dev, name, errp);
215 return;
216 }
217
218 visit_type_uint16(v, ptr, name, errp);
219 }
220
221 PropertyInfo qdev_prop_uint16 = {
222 .name = "uint16",
223 .get = get_uint16,
224 .set = set_uint16,
225 };
226
227 /* --- 32bit integer --- */
228
229 static void get_uint32(Object *obj, Visitor *v, void *opaque,
230 const char *name, Error **errp)
231 {
232 DeviceState *dev = DEVICE(obj);
233 Property *prop = opaque;
234 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
235
236 visit_type_uint32(v, ptr, name, errp);
237 }
238
239 static void set_uint32(Object *obj, Visitor *v, void *opaque,
240 const char *name, Error **errp)
241 {
242 DeviceState *dev = DEVICE(obj);
243 Property *prop = opaque;
244 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
245
246 if (dev->realized) {
247 qdev_prop_set_after_realize(dev, name, errp);
248 return;
249 }
250
251 visit_type_uint32(v, ptr, name, errp);
252 }
253
254 static void get_int32(Object *obj, Visitor *v, void *opaque,
255 const char *name, Error **errp)
256 {
257 DeviceState *dev = DEVICE(obj);
258 Property *prop = opaque;
259 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
260
261 visit_type_int32(v, ptr, name, errp);
262 }
263
264 static void set_int32(Object *obj, Visitor *v, void *opaque,
265 const char *name, Error **errp)
266 {
267 DeviceState *dev = DEVICE(obj);
268 Property *prop = opaque;
269 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
270
271 if (dev->realized) {
272 qdev_prop_set_after_realize(dev, name, errp);
273 return;
274 }
275
276 visit_type_int32(v, ptr, name, errp);
277 }
278
279 PropertyInfo qdev_prop_uint32 = {
280 .name = "uint32",
281 .get = get_uint32,
282 .set = set_uint32,
283 };
284
285 PropertyInfo qdev_prop_int32 = {
286 .name = "int32",
287 .get = get_int32,
288 .set = set_int32,
289 };
290
291 /* --- 64bit integer --- */
292
293 static void get_uint64(Object *obj, Visitor *v, void *opaque,
294 const char *name, Error **errp)
295 {
296 DeviceState *dev = DEVICE(obj);
297 Property *prop = opaque;
298 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
299
300 visit_type_uint64(v, ptr, name, errp);
301 }
302
303 static void set_uint64(Object *obj, Visitor *v, void *opaque,
304 const char *name, Error **errp)
305 {
306 DeviceState *dev = DEVICE(obj);
307 Property *prop = opaque;
308 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
309
310 if (dev->realized) {
311 qdev_prop_set_after_realize(dev, name, errp);
312 return;
313 }
314
315 visit_type_uint64(v, ptr, name, errp);
316 }
317
318 PropertyInfo qdev_prop_uint64 = {
319 .name = "uint64",
320 .get = get_uint64,
321 .set = set_uint64,
322 };
323
324 /* --- string --- */
325
326 static void release_string(Object *obj, const char *name, void *opaque)
327 {
328 Property *prop = opaque;
329 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop));
330 }
331
332 static void get_string(Object *obj, Visitor *v, void *opaque,
333 const char *name, Error **errp)
334 {
335 DeviceState *dev = DEVICE(obj);
336 Property *prop = opaque;
337 char **ptr = qdev_get_prop_ptr(dev, prop);
338
339 if (!*ptr) {
340 char *str = (char *)"";
341 visit_type_str(v, &str, name, errp);
342 } else {
343 visit_type_str(v, ptr, name, errp);
344 }
345 }
346
347 static void set_string(Object *obj, Visitor *v, void *opaque,
348 const char *name, Error **errp)
349 {
350 DeviceState *dev = DEVICE(obj);
351 Property *prop = opaque;
352 char **ptr = qdev_get_prop_ptr(dev, prop);
353 Error *local_err = NULL;
354 char *str;
355
356 if (dev->realized) {
357 qdev_prop_set_after_realize(dev, name, errp);
358 return;
359 }
360
361 visit_type_str(v, &str, name, &local_err);
362 if (local_err) {
363 error_propagate(errp, local_err);
364 return;
365 }
366 if (*ptr) {
367 g_free(*ptr);
368 }
369 *ptr = str;
370 }
371
372 PropertyInfo qdev_prop_string = {
373 .name = "str",
374 .release = release_string,
375 .get = get_string,
376 .set = set_string,
377 };
378
379 /* --- pointer --- */
380
381 /* Not a proper property, just for dirty hacks. TODO Remove it! */
382 PropertyInfo qdev_prop_ptr = {
383 .name = "ptr",
384 };
385
386 /* --- mac address --- */
387
388 /*
389 * accepted syntax versions:
390 * 01:02:03:04:05:06
391 * 01-02-03-04-05-06
392 */
393 static void get_mac(Object *obj, Visitor *v, void *opaque,
394 const char *name, Error **errp)
395 {
396 DeviceState *dev = DEVICE(obj);
397 Property *prop = opaque;
398 MACAddr *mac = qdev_get_prop_ptr(dev, prop);
399 char buffer[2 * 6 + 5 + 1];
400 char *p = buffer;
401
402 snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
403 mac->a[0], mac->a[1], mac->a[2],
404 mac->a[3], mac->a[4], mac->a[5]);
405
406 visit_type_str(v, &p, name, errp);
407 }
408
409 static void set_mac(Object *obj, Visitor *v, void *opaque,
410 const char *name, Error **errp)
411 {
412 DeviceState *dev = DEVICE(obj);
413 Property *prop = opaque;
414 MACAddr *mac = qdev_get_prop_ptr(dev, prop);
415 Error *local_err = NULL;
416 int i, pos;
417 char *str, *p;
418
419 if (dev->realized) {
420 qdev_prop_set_after_realize(dev, name, errp);
421 return;
422 }
423
424 visit_type_str(v, &str, name, &local_err);
425 if (local_err) {
426 error_propagate(errp, local_err);
427 return;
428 }
429
430 for (i = 0, pos = 0; i < 6; i++, pos += 3) {
431 if (!qemu_isxdigit(str[pos])) {
432 goto inval;
433 }
434 if (!qemu_isxdigit(str[pos+1])) {
435 goto inval;
436 }
437 if (i == 5) {
438 if (str[pos+2] != '\0') {
439 goto inval;
440 }
441 } else {
442 if (str[pos+2] != ':' && str[pos+2] != '-') {
443 goto inval;
444 }
445 }
446 mac->a[i] = strtol(str+pos, &p, 16);
447 }
448 g_free(str);
449 return;
450
451 inval:
452 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
453 g_free(str);
454 }
455
456 PropertyInfo qdev_prop_macaddr = {
457 .name = "str",
458 .legacy_name = "macaddr",
459 .get = get_mac,
460 .set = set_mac,
461 };
462
463 /* --- lost tick policy --- */
464
465 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int));
466
467 PropertyInfo qdev_prop_losttickpolicy = {
468 .name = "LostTickPolicy",
469 .enum_table = LostTickPolicy_lookup,
470 .get = get_enum,
471 .set = set_enum,
472 };
473
474 /* --- BIOS CHS translation */
475
476 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int));
477
478 PropertyInfo qdev_prop_bios_chs_trans = {
479 .name = "BiosAtaTranslation",
480 .legacy_name = "bios-chs-trans",
481 .enum_table = BiosAtaTranslation_lookup,
482 .get = get_enum,
483 .set = set_enum,
484 };
485
486 /* --- pci address --- */
487
488 /*
489 * bus-local address, i.e. "$slot" or "$slot.$fn"
490 */
491 static void set_pci_devfn(Object *obj, Visitor *v, void *opaque,
492 const char *name, Error **errp)
493 {
494 DeviceState *dev = DEVICE(obj);
495 Property *prop = opaque;
496 int32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
497 unsigned int slot, fn, n;
498 Error *local_err = NULL;
499 char *str;
500
501 if (dev->realized) {
502 qdev_prop_set_after_realize(dev, name, errp);
503 return;
504 }
505
506 visit_type_str(v, &str, name, &local_err);
507 if (local_err) {
508 error_free(local_err);
509 local_err = NULL;
510 visit_type_int32(v, &value, name, &local_err);
511 if (local_err) {
512 error_propagate(errp, local_err);
513 } else if (value < -1 || value > 255) {
514 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
515 "pci_devfn");
516 } else {
517 *ptr = value;
518 }
519 return;
520 }
521
522 if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
523 fn = 0;
524 if (sscanf(str, "%x%n", &slot, &n) != 1) {
525 goto invalid;
526 }
527 }
528 if (str[n] != '\0' || fn > 7 || slot > 31) {
529 goto invalid;
530 }
531 *ptr = slot << 3 | fn;
532 g_free(str);
533 return;
534
535 invalid:
536 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
537 g_free(str);
538 }
539
540 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest,
541 size_t len)
542 {
543 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
544
545 if (*ptr == -1) {
546 return snprintf(dest, len, "<unset>");
547 } else {
548 return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
549 }
550 }
551
552 PropertyInfo qdev_prop_pci_devfn = {
553 .name = "int32",
554 .legacy_name = "pci-devfn",
555 .print = print_pci_devfn,
556 .get = get_int32,
557 .set = set_pci_devfn,
558 };
559
560 /* --- blocksize --- */
561
562 static void set_blocksize(Object *obj, Visitor *v, void *opaque,
563 const char *name, Error **errp)
564 {
565 DeviceState *dev = DEVICE(obj);
566 Property *prop = opaque;
567 uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop);
568 Error *local_err = NULL;
569 const int64_t min = 512;
570 const int64_t max = 32768;
571
572 if (dev->realized) {
573 qdev_prop_set_after_realize(dev, name, errp);
574 return;
575 }
576
577 visit_type_uint16(v, &value, name, &local_err);
578 if (local_err) {
579 error_propagate(errp, local_err);
580 return;
581 }
582 if (value < min || value > max) {
583 error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
584 dev->id?:"", name, (int64_t)value, min, max);
585 return;
586 }
587
588 /* We rely on power-of-2 blocksizes for bitmasks */
589 if ((value & (value - 1)) != 0) {
590 error_set(errp, QERR_PROPERTY_VALUE_NOT_POWER_OF_2,
591 dev->id?:"", name, (int64_t)value);
592 return;
593 }
594
595 *ptr = value;
596 }
597
598 PropertyInfo qdev_prop_blocksize = {
599 .name = "uint16",
600 .legacy_name = "blocksize",
601 .get = get_uint16,
602 .set = set_blocksize,
603 };
604
605 /* --- pci host address --- */
606
607 static void get_pci_host_devaddr(Object *obj, Visitor *v, void *opaque,
608 const char *name, Error **errp)
609 {
610 DeviceState *dev = DEVICE(obj);
611 Property *prop = opaque;
612 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
613 char buffer[] = "xxxx:xx:xx.x";
614 char *p = buffer;
615 int rc = 0;
616
617 rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%d",
618 addr->domain, addr->bus, addr->slot, addr->function);
619 assert(rc == sizeof(buffer) - 1);
620
621 visit_type_str(v, &p, name, errp);
622 }
623
624 /*
625 * Parse [<domain>:]<bus>:<slot>.<func>
626 * if <domain> is not supplied, it's assumed to be 0.
627 */
628 static void set_pci_host_devaddr(Object *obj, Visitor *v, void *opaque,
629 const char *name, Error **errp)
630 {
631 DeviceState *dev = DEVICE(obj);
632 Property *prop = opaque;
633 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
634 Error *local_err = NULL;
635 char *str, *p;
636 char *e;
637 unsigned long val;
638 unsigned long dom = 0, bus = 0;
639 unsigned int slot = 0, func = 0;
640
641 if (dev->realized) {
642 qdev_prop_set_after_realize(dev, name, errp);
643 return;
644 }
645
646 visit_type_str(v, &str, name, &local_err);
647 if (local_err) {
648 error_propagate(errp, local_err);
649 return;
650 }
651
652 p = str;
653 val = strtoul(p, &e, 16);
654 if (e == p || *e != ':') {
655 goto inval;
656 }
657 bus = val;
658
659 p = e + 1;
660 val = strtoul(p, &e, 16);
661 if (e == p) {
662 goto inval;
663 }
664 if (*e == ':') {
665 dom = bus;
666 bus = val;
667 p = e + 1;
668 val = strtoul(p, &e, 16);
669 if (e == p) {
670 goto inval;
671 }
672 }
673 slot = val;
674
675 if (*e != '.') {
676 goto inval;
677 }
678 p = e + 1;
679 val = strtoul(p, &e, 10);
680 if (e == p) {
681 goto inval;
682 }
683 func = val;
684
685 if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) {
686 goto inval;
687 }
688
689 if (*e) {
690 goto inval;
691 }
692
693 addr->domain = dom;
694 addr->bus = bus;
695 addr->slot = slot;
696 addr->function = func;
697
698 g_free(str);
699 return;
700
701 inval:
702 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
703 g_free(str);
704 }
705
706 PropertyInfo qdev_prop_pci_host_devaddr = {
707 .name = "str",
708 .legacy_name = "pci-host-devaddr",
709 .get = get_pci_host_devaddr,
710 .set = set_pci_host_devaddr,
711 };
712
713 /* --- support for array properties --- */
714
715 /* Used as an opaque for the object properties we add for each
716 * array element. Note that the struct Property must be first
717 * in the struct so that a pointer to this works as the opaque
718 * for the underlying element's property hooks as well as for
719 * our own release callback.
720 */
721 typedef struct {
722 struct Property prop;
723 char *propname;
724 ObjectPropertyRelease *release;
725 } ArrayElementProperty;
726
727 /* object property release callback for array element properties:
728 * we call the underlying element's property release hook, and
729 * then free the memory we allocated when we added the property.
730 */
731 static void array_element_release(Object *obj, const char *name, void *opaque)
732 {
733 ArrayElementProperty *p = opaque;
734 if (p->release) {
735 p->release(obj, name, opaque);
736 }
737 g_free(p->propname);
738 g_free(p);
739 }
740
741 static void set_prop_arraylen(Object *obj, Visitor *v, void *opaque,
742 const char *name, Error **errp)
743 {
744 /* Setter for the property which defines the length of a
745 * variable-sized property array. As well as actually setting the
746 * array-length field in the device struct, we have to create the
747 * array itself and dynamically add the corresponding properties.
748 */
749 DeviceState *dev = DEVICE(obj);
750 Property *prop = opaque;
751 uint32_t *alenptr = qdev_get_prop_ptr(dev, prop);
752 void **arrayptr = (void *)dev + prop->arrayoffset;
753 void *eltptr;
754 const char *arrayname;
755 int i;
756
757 if (dev->realized) {
758 qdev_prop_set_after_realize(dev, name, errp);
759 return;
760 }
761 if (*alenptr) {
762 error_setg(errp, "array size property %s may not be set more than once",
763 name);
764 return;
765 }
766 visit_type_uint32(v, alenptr, name, errp);
767 if (error_is_set(errp)) {
768 return;
769 }
770 if (!*alenptr) {
771 return;
772 }
773
774 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
775 * strip it off so we can get the name of the array itself.
776 */
777 assert(strncmp(name, PROP_ARRAY_LEN_PREFIX,
778 strlen(PROP_ARRAY_LEN_PREFIX)) == 0);
779 arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX);
780
781 /* Note that it is the responsibility of the individual device's deinit
782 * to free the array proper.
783 */
784 *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize);
785 for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) {
786 char *propname = g_strdup_printf("%s[%d]", arrayname, i);
787 ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1);
788 arrayprop->release = prop->arrayinfo->release;
789 arrayprop->propname = propname;
790 arrayprop->prop.info = prop->arrayinfo;
791 arrayprop->prop.name = propname;
792 /* This ugly piece of pointer arithmetic sets up the offset so
793 * that when the underlying get/set hooks call qdev_get_prop_ptr
794 * they get the right answer despite the array element not actually
795 * being inside the device struct.
796 */
797 arrayprop->prop.offset = eltptr - (void *)dev;
798 assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr);
799 object_property_add(obj, propname,
800 arrayprop->prop.info->name,
801 arrayprop->prop.info->get,
802 arrayprop->prop.info->set,
803 array_element_release,
804 arrayprop, errp);
805 if (error_is_set(errp)) {
806 return;
807 }
808 }
809 }
810
811 PropertyInfo qdev_prop_arraylen = {
812 .name = "uint32",
813 .get = get_uint32,
814 .set = set_prop_arraylen,
815 };
816
817 /* --- public helpers --- */
818
819 static Property *qdev_prop_walk(Property *props, const char *name)
820 {
821 if (!props) {
822 return NULL;
823 }
824 while (props->name) {
825 if (strcmp(props->name, name) == 0) {
826 return props;
827 }
828 props++;
829 }
830 return NULL;
831 }
832
833 static Property *qdev_prop_find(DeviceState *dev, const char *name)
834 {
835 ObjectClass *class;
836 Property *prop;
837
838 /* device properties */
839 class = object_get_class(OBJECT(dev));
840 do {
841 prop = qdev_prop_walk(DEVICE_CLASS(class)->props, name);
842 if (prop) {
843 return prop;
844 }
845 class = object_class_get_parent(class);
846 } while (class != object_class_by_name(TYPE_DEVICE));
847
848 return NULL;
849 }
850
851 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,
852 Property *prop, const char *value)
853 {
854 switch (ret) {
855 case -EEXIST:
856 error_set(errp, QERR_PROPERTY_VALUE_IN_USE,
857 object_get_typename(OBJECT(dev)), prop->name, value);
858 break;
859 default:
860 case -EINVAL:
861 error_set(errp, QERR_PROPERTY_VALUE_BAD,
862 object_get_typename(OBJECT(dev)), prop->name, value);
863 break;
864 case -ENOENT:
865 error_set(errp, QERR_PROPERTY_VALUE_NOT_FOUND,
866 object_get_typename(OBJECT(dev)), prop->name, value);
867 break;
868 case 0:
869 break;
870 }
871 }
872
873 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
874 {
875 object_property_set_bool(OBJECT(dev), value, name, &error_abort);
876 }
877
878 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
879 {
880 object_property_set_int(OBJECT(dev), value, name, &error_abort);
881 }
882
883 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
884 {
885 object_property_set_int(OBJECT(dev), value, name, &error_abort);
886 }
887
888 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
889 {
890 object_property_set_int(OBJECT(dev), value, name, &error_abort);
891 }
892
893 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
894 {
895 object_property_set_int(OBJECT(dev), value, name, &error_abort);
896 }
897
898 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
899 {
900 object_property_set_int(OBJECT(dev), value, name, &error_abort);
901 }
902
903 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value)
904 {
905 object_property_set_str(OBJECT(dev), value, name, &error_abort);
906 }
907
908 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value)
909 {
910 char str[2 * 6 + 5 + 1];
911 snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
912 value[0], value[1], value[2], value[3], value[4], value[5]);
913
914 object_property_set_str(OBJECT(dev), str, name, &error_abort);
915 }
916
917 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
918 {
919 Property *prop;
920
921 prop = qdev_prop_find(dev, name);
922 object_property_set_str(OBJECT(dev), prop->info->enum_table[value],
923 name, &error_abort);
924 }
925
926 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
927 {
928 Property *prop;
929 void **ptr;
930
931 prop = qdev_prop_find(dev, name);
932 assert(prop && prop->info == &qdev_prop_ptr);
933 ptr = qdev_get_prop_ptr(dev, prop);
934 *ptr = value;
935 }
936
937 static QTAILQ_HEAD(, GlobalProperty) global_props =
938 QTAILQ_HEAD_INITIALIZER(global_props);
939
940 void qdev_prop_register_global(GlobalProperty *prop)
941 {
942 QTAILQ_INSERT_TAIL(&global_props, prop, next);
943 }
944
945 void qdev_prop_register_global_list(GlobalProperty *props)
946 {
947 int i;
948
949 for (i = 0; props[i].driver != NULL; i++) {
950 qdev_prop_register_global(props+i);
951 }
952 }
953
954 void qdev_prop_set_globals_for_type(DeviceState *dev, const char *typename,
955 Error **errp)
956 {
957 GlobalProperty *prop;
958
959 QTAILQ_FOREACH(prop, &global_props, next) {
960 Error *err = NULL;
961
962 if (strcmp(typename, prop->driver) != 0) {
963 continue;
964 }
965 object_property_parse(OBJECT(dev), prop->value, prop->property, &err);
966 if (err != NULL) {
967 error_propagate(errp, err);
968 return;
969 }
970 }
971 }
972
973 void qdev_prop_set_globals(DeviceState *dev, Error **errp)
974 {
975 ObjectClass *class = object_get_class(OBJECT(dev));
976
977 do {
978 Error *err = NULL;
979
980 qdev_prop_set_globals_for_type(dev, object_class_get_name(class),
981 &err);
982 if (err != NULL) {
983 error_propagate(errp, err);
984 return;
985 }
986 class = object_class_get_parent(class);
987 } while (class);
988 }
989
990 /* --- 64bit unsigned int 'size' type --- */
991
992 static void get_size(Object *obj, Visitor *v, void *opaque,
993 const char *name, Error **errp)
994 {
995 DeviceState *dev = DEVICE(obj);
996 Property *prop = opaque;
997 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
998
999 visit_type_size(v, ptr, name, errp);
1000 }
1001
1002 static void set_size(Object *obj, Visitor *v, void *opaque,
1003 const char *name, Error **errp)
1004 {
1005 DeviceState *dev = DEVICE(obj);
1006 Property *prop = opaque;
1007 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
1008
1009 visit_type_size(v, ptr, name, errp);
1010 }
1011
1012 PropertyInfo qdev_prop_size = {
1013 .name = "size",
1014 .get = get_size,
1015 .set = set_size,
1016 };