?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20150316' into staging
[qemu/qmp-unstable.git] / hw / core / qdev-properties.c
blob570d5f0bad28125ed3dc1522434deac295820b22
1 #include "net/net.h"
2 #include "hw/qdev.h"
3 #include "qapi/qmp/qerror.h"
4 #include "sysemu/block-backend.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 .description = "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 .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
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 .description = "Logical CHS translation algorithm, "
481 "auto/none/lba/large/rechs",
482 .enum_table = BiosAtaTranslation_lookup,
483 .get = get_enum,
484 .set = set_enum,
485 };
486
487 /* --- pci address --- */
488
489 /*
490 * bus-local address, i.e. "$slot" or "$slot.$fn"
491 */
492 static void set_pci_devfn(Object *obj, Visitor *v, void *opaque,
493 const char *name, Error **errp)
494 {
495 DeviceState *dev = DEVICE(obj);
496 Property *prop = opaque;
497 int32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
498 unsigned int slot, fn, n;
499 Error *local_err = NULL;
500 char *str;
501
502 if (dev->realized) {
503 qdev_prop_set_after_realize(dev, name, errp);
504 return;
505 }
506
507 visit_type_str(v, &str, name, &local_err);
508 if (local_err) {
509 error_free(local_err);
510 local_err = NULL;
511 visit_type_int32(v, &value, name, &local_err);
512 if (local_err) {
513 error_propagate(errp, local_err);
514 } else if (value < -1 || value > 255) {
515 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
516 "pci_devfn");
517 } else {
518 *ptr = value;
519 }
520 return;
521 }
522
523 if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
524 fn = 0;
525 if (sscanf(str, "%x%n", &slot, &n) != 1) {
526 goto invalid;
527 }
528 }
529 if (str[n] != '\0' || fn > 7 || slot > 31) {
530 goto invalid;
531 }
532 *ptr = slot << 3 | fn;
533 g_free(str);
534 return;
535
536 invalid:
537 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
538 g_free(str);
539 }
540
541 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest,
542 size_t len)
543 {
544 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
545
546 if (*ptr == -1) {
547 return snprintf(dest, len, "<unset>");
548 } else {
549 return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
550 }
551 }
552
553 PropertyInfo qdev_prop_pci_devfn = {
554 .name = "int32",
555 .description = "Slot and optional function number, example: 06.0 or 06",
556 .print = print_pci_devfn,
557 .get = get_int32,
558 .set = set_pci_devfn,
559 };
560
561 /* --- blocksize --- */
562
563 static void set_blocksize(Object *obj, Visitor *v, void *opaque,
564 const char *name, Error **errp)
565 {
566 DeviceState *dev = DEVICE(obj);
567 Property *prop = opaque;
568 uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop);
569 Error *local_err = NULL;
570 const int64_t min = 512;
571 const int64_t max = 32768;
572
573 if (dev->realized) {
574 qdev_prop_set_after_realize(dev, name, errp);
575 return;
576 }
577
578 visit_type_uint16(v, &value, name, &local_err);
579 if (local_err) {
580 error_propagate(errp, local_err);
581 return;
582 }
583 /* value of 0 means "unset" */
584 if (value && (value < min || value > max)) {
585 error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
586 dev->id?:"", name, (int64_t)value, min, max);
587 return;
588 }
589
590 /* We rely on power-of-2 blocksizes for bitmasks */
591 if ((value & (value - 1)) != 0) {
592 error_setg(errp,
593 "Property %s.%s doesn't take value '%" PRId64 "', it's not a power of 2",
594 dev->id ?: "", name, (int64_t)value);
595 return;
596 }
597
598 *ptr = value;
599 }
600
601 PropertyInfo qdev_prop_blocksize = {
602 .name = "uint16",
603 .description = "A power of two between 512 and 32768",
604 .get = get_uint16,
605 .set = set_blocksize,
606 };
607
608 /* --- pci host address --- */
609
610 static void get_pci_host_devaddr(Object *obj, Visitor *v, void *opaque,
611 const char *name, Error **errp)
612 {
613 DeviceState *dev = DEVICE(obj);
614 Property *prop = opaque;
615 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
616 char buffer[] = "xxxx:xx:xx.x";
617 char *p = buffer;
618 int rc = 0;
619
620 rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%d",
621 addr->domain, addr->bus, addr->slot, addr->function);
622 assert(rc == sizeof(buffer) - 1);
623
624 visit_type_str(v, &p, name, errp);
625 }
626
627 /*
628 * Parse [<domain>:]<bus>:<slot>.<func>
629 * if <domain> is not supplied, it's assumed to be 0.
630 */
631 static void set_pci_host_devaddr(Object *obj, Visitor *v, void *opaque,
632 const char *name, Error **errp)
633 {
634 DeviceState *dev = DEVICE(obj);
635 Property *prop = opaque;
636 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
637 Error *local_err = NULL;
638 char *str, *p;
639 char *e;
640 unsigned long val;
641 unsigned long dom = 0, bus = 0;
642 unsigned int slot = 0, func = 0;
643
644 if (dev->realized) {
645 qdev_prop_set_after_realize(dev, name, errp);
646 return;
647 }
648
649 visit_type_str(v, &str, name, &local_err);
650 if (local_err) {
651 error_propagate(errp, local_err);
652 return;
653 }
654
655 p = str;
656 val = strtoul(p, &e, 16);
657 if (e == p || *e != ':') {
658 goto inval;
659 }
660 bus = val;
661
662 p = e + 1;
663 val = strtoul(p, &e, 16);
664 if (e == p) {
665 goto inval;
666 }
667 if (*e == ':') {
668 dom = bus;
669 bus = val;
670 p = e + 1;
671 val = strtoul(p, &e, 16);
672 if (e == p) {
673 goto inval;
674 }
675 }
676 slot = val;
677
678 if (*e != '.') {
679 goto inval;
680 }
681 p = e + 1;
682 val = strtoul(p, &e, 10);
683 if (e == p) {
684 goto inval;
685 }
686 func = val;
687
688 if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) {
689 goto inval;
690 }
691
692 if (*e) {
693 goto inval;
694 }
695
696 addr->domain = dom;
697 addr->bus = bus;
698 addr->slot = slot;
699 addr->function = func;
700
701 g_free(str);
702 return;
703
704 inval:
705 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
706 g_free(str);
707 }
708
709 PropertyInfo qdev_prop_pci_host_devaddr = {
710 .name = "str",
711 .description = "Address (bus/device/function) of "
712 "the host device, example: 04:10.0",
713 .get = get_pci_host_devaddr,
714 .set = set_pci_host_devaddr,
715 };
716
717 /* --- support for array properties --- */
718
719 /* Used as an opaque for the object properties we add for each
720 * array element. Note that the struct Property must be first
721 * in the struct so that a pointer to this works as the opaque
722 * for the underlying element's property hooks as well as for
723 * our own release callback.
724 */
725 typedef struct {
726 struct Property prop;
727 char *propname;
728 ObjectPropertyRelease *release;
729 } ArrayElementProperty;
730
731 /* object property release callback for array element properties:
732 * we call the underlying element's property release hook, and
733 * then free the memory we allocated when we added the property.
734 */
735 static void array_element_release(Object *obj, const char *name, void *opaque)
736 {
737 ArrayElementProperty *p = opaque;
738 if (p->release) {
739 p->release(obj, name, opaque);
740 }
741 g_free(p->propname);
742 g_free(p);
743 }
744
745 static void set_prop_arraylen(Object *obj, Visitor *v, void *opaque,
746 const char *name, Error **errp)
747 {
748 /* Setter for the property which defines the length of a
749 * variable-sized property array. As well as actually setting the
750 * array-length field in the device struct, we have to create the
751 * array itself and dynamically add the corresponding properties.
752 */
753 DeviceState *dev = DEVICE(obj);
754 Property *prop = opaque;
755 uint32_t *alenptr = qdev_get_prop_ptr(dev, prop);
756 void **arrayptr = (void *)dev + prop->arrayoffset;
757 Error *local_err = NULL;
758 void *eltptr;
759 const char *arrayname;
760 int i;
761
762 if (dev->realized) {
763 qdev_prop_set_after_realize(dev, name, errp);
764 return;
765 }
766 if (*alenptr) {
767 error_setg(errp, "array size property %s may not be set more than once",
768 name);
769 return;
770 }
771 visit_type_uint32(v, alenptr, name, &local_err);
772 if (local_err) {
773 error_propagate(errp, local_err);
774 return;
775 }
776 if (!*alenptr) {
777 return;
778 }
779
780 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
781 * strip it off so we can get the name of the array itself.
782 */
783 assert(strncmp(name, PROP_ARRAY_LEN_PREFIX,
784 strlen(PROP_ARRAY_LEN_PREFIX)) == 0);
785 arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX);
786
787 /* Note that it is the responsibility of the individual device's deinit
788 * to free the array proper.
789 */
790 *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize);
791 for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) {
792 char *propname = g_strdup_printf("%s[%d]", arrayname, i);
793 ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1);
794 arrayprop->release = prop->arrayinfo->release;
795 arrayprop->propname = propname;
796 arrayprop->prop.info = prop->arrayinfo;
797 arrayprop->prop.name = propname;
798 /* This ugly piece of pointer arithmetic sets up the offset so
799 * that when the underlying get/set hooks call qdev_get_prop_ptr
800 * they get the right answer despite the array element not actually
801 * being inside the device struct.
802 */
803 arrayprop->prop.offset = eltptr - (void *)dev;
804 assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr);
805 object_property_add(obj, propname,
806 arrayprop->prop.info->name,
807 arrayprop->prop.info->get,
808 arrayprop->prop.info->set,
809 array_element_release,
810 arrayprop, &local_err);
811 if (local_err) {
812 error_propagate(errp, local_err);
813 return;
814 }
815 }
816 }
817
818 PropertyInfo qdev_prop_arraylen = {
819 .name = "uint32",
820 .get = get_uint32,
821 .set = set_prop_arraylen,
822 };
823
824 /* --- public helpers --- */
825
826 static Property *qdev_prop_walk(Property *props, const char *name)
827 {
828 if (!props) {
829 return NULL;
830 }
831 while (props->name) {
832 if (strcmp(props->name, name) == 0) {
833 return props;
834 }
835 props++;
836 }
837 return NULL;
838 }
839
840 static Property *qdev_prop_find(DeviceState *dev, const char *name)
841 {
842 ObjectClass *class;
843 Property *prop;
844
845 /* device properties */
846 class = object_get_class(OBJECT(dev));
847 do {
848 prop = qdev_prop_walk(DEVICE_CLASS(class)->props, name);
849 if (prop) {
850 return prop;
851 }
852 class = object_class_get_parent(class);
853 } while (class != object_class_by_name(TYPE_DEVICE));
854
855 return NULL;
856 }
857
858 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,
859 Property *prop, const char *value)
860 {
861 switch (ret) {
862 case -EEXIST:
863 error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use",
864 object_get_typename(OBJECT(dev)), prop->name, value);
865 break;
866 default:
867 case -EINVAL:
868 error_set(errp, QERR_PROPERTY_VALUE_BAD,
869 object_get_typename(OBJECT(dev)), prop->name, value);
870 break;
871 case -ENOENT:
872 error_setg(errp, "Property '%s.%s' can't find value '%s'",
873 object_get_typename(OBJECT(dev)), prop->name, value);
874 break;
875 case 0:
876 break;
877 }
878 }
879
880 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
881 {
882 object_property_set_bool(OBJECT(dev), value, name, &error_abort);
883 }
884
885 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
886 {
887 object_property_set_int(OBJECT(dev), value, name, &error_abort);
888 }
889
890 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
891 {
892 object_property_set_int(OBJECT(dev), value, name, &error_abort);
893 }
894
895 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
896 {
897 object_property_set_int(OBJECT(dev), value, name, &error_abort);
898 }
899
900 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
901 {
902 object_property_set_int(OBJECT(dev), value, name, &error_abort);
903 }
904
905 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
906 {
907 object_property_set_int(OBJECT(dev), value, name, &error_abort);
908 }
909
910 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value)
911 {
912 object_property_set_str(OBJECT(dev), value, name, &error_abort);
913 }
914
915 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value)
916 {
917 char str[2 * 6 + 5 + 1];
918 snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
919 value[0], value[1], value[2], value[3], value[4], value[5]);
920
921 object_property_set_str(OBJECT(dev), str, name, &error_abort);
922 }
923
924 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
925 {
926 Property *prop;
927
928 prop = qdev_prop_find(dev, name);
929 object_property_set_str(OBJECT(dev), prop->info->enum_table[value],
930 name, &error_abort);
931 }
932
933 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
934 {
935 Property *prop;
936 void **ptr;
937
938 prop = qdev_prop_find(dev, name);
939 assert(prop && prop->info == &qdev_prop_ptr);
940 ptr = qdev_get_prop_ptr(dev, prop);
941 *ptr = value;
942 }
943
944 static QTAILQ_HEAD(, GlobalProperty) global_props =
945 QTAILQ_HEAD_INITIALIZER(global_props);
946
947 void qdev_prop_register_global(GlobalProperty *prop)
948 {
949 QTAILQ_INSERT_TAIL(&global_props, prop, next);
950 }
951
952 void qdev_prop_register_global_list(GlobalProperty *props)
953 {
954 int i;
955
956 for (i = 0; props[i].driver != NULL; i++) {
957 qdev_prop_register_global(props+i);
958 }
959 }
960
961 int qdev_prop_check_globals(void)
962 {
963 GlobalProperty *prop;
964 int ret = 0;
965
966 QTAILQ_FOREACH(prop, &global_props, next) {
967 ObjectClass *oc;
968 DeviceClass *dc;
969 if (prop->used) {
970 continue;
971 }
972 if (!prop->user_provided) {
973 continue;
974 }
975 oc = object_class_by_name(prop->driver);
976 oc = object_class_dynamic_cast(oc, TYPE_DEVICE);
977 if (!oc) {
978 error_report("Warning: global %s.%s has invalid class name",
979 prop->driver, prop->property);
980 ret = 1;
981 continue;
982 }
983 dc = DEVICE_CLASS(oc);
984 if (!dc->hotpluggable && !prop->used) {
985 error_report("Warning: global %s.%s=%s not used",
986 prop->driver, prop->property, prop->value);
987 ret = 1;
988 continue;
989 }
990 }
991 return ret;
992 }
993
994 static void qdev_prop_set_globals_for_type(DeviceState *dev,
995 const char *typename)
996 {
997 GlobalProperty *prop;
998
999 QTAILQ_FOREACH(prop, &global_props, next) {
1000 Error *err = NULL;
1001
1002 if (strcmp(typename, prop->driver) != 0) {
1003 continue;
1004 }
1005 prop->used = true;
1006 object_property_parse(OBJECT(dev), prop->value, prop->property, &err);
1007 if (err != NULL) {
1008 assert(prop->user_provided);
1009 error_report("Warning: global %s.%s=%s ignored (%s)",
1010 prop->driver, prop->property, prop->value,
1011 error_get_pretty(err));
1012 error_free(err);
1013 return;
1014 }
1015 }
1016 }
1017
1018 void qdev_prop_set_globals(DeviceState *dev)
1019 {
1020 ObjectClass *class = object_get_class(OBJECT(dev));
1021
1022 do {
1023 qdev_prop_set_globals_for_type(dev, object_class_get_name(class));
1024 class = object_class_get_parent(class);
1025 } while (class);
1026 }
1027
1028 /* --- 64bit unsigned int 'size' type --- */
1029
1030 static void get_size(Object *obj, Visitor *v, void *opaque,
1031 const char *name, Error **errp)
1032 {
1033 DeviceState *dev = DEVICE(obj);
1034 Property *prop = opaque;
1035 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
1036
1037 visit_type_size(v, ptr, name, errp);
1038 }
1039
1040 static void set_size(Object *obj, Visitor *v, void *opaque,
1041 const char *name, Error **errp)
1042 {
1043 DeviceState *dev = DEVICE(obj);
1044 Property *prop = opaque;
1045 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
1046
1047 visit_type_size(v, ptr, name, errp);
1048 }
1049
1050 PropertyInfo qdev_prop_size = {
1051 .name = "size",
1052 .get = get_size,
1053 .set = set_size,
1054 };
QEMU Monitor Protocol