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