3 #include "qapi/qmp/qerror.h"
4 #include "sysemu/blockdev.h"
5 #include "hw/block/block.h"
7 #include "qapi/visitor.h"
8 #include "sysemu/char.h"
10 void qdev_prop_set_after_realize(DeviceState
*dev
, const char *name
,
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
)));
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
)));
24 void *qdev_get_prop_ptr(DeviceState
*dev
, Property
*prop
)
31 static void get_enum(Object
*obj
, Visitor
*v
, void *opaque
,
32 const char *name
, Error
**errp
)
34 DeviceState
*dev
= DEVICE(obj
);
35 Property
*prop
= opaque
;
36 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
38 visit_type_enum(v
, ptr
, prop
->info
->enum_table
,
39 prop
->info
->name
, prop
->name
, errp
);
42 static void set_enum(Object
*obj
, Visitor
*v
, void *opaque
,
43 const char *name
, Error
**errp
)
45 DeviceState
*dev
= DEVICE(obj
);
46 Property
*prop
= opaque
;
47 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
50 qdev_prop_set_after_realize(dev
, name
, errp
);
54 visit_type_enum(v
, ptr
, prop
->info
->enum_table
,
55 prop
->info
->name
, prop
->name
, errp
);
60 static uint32_t qdev_get_prop_mask(Property
*prop
)
62 assert(prop
->info
== &qdev_prop_bit
);
63 return 0x1 << prop
->bitnr
;
66 static void bit_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
68 uint32_t *p
= qdev_get_prop_ptr(dev
, props
);
69 uint32_t mask
= qdev_get_prop_mask(props
);
77 static int prop_print_bit(DeviceState
*dev
, Property
*prop
, char *dest
,
80 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
81 return snprintf(dest
, len
, (*p
& qdev_get_prop_mask(prop
)) ? "on" : "off");
84 static void prop_get_bit(Object
*obj
, Visitor
*v
, void *opaque
,
85 const char *name
, Error
**errp
)
87 DeviceState
*dev
= DEVICE(obj
);
88 Property
*prop
= opaque
;
89 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
90 bool value
= (*p
& qdev_get_prop_mask(prop
)) != 0;
92 visit_type_bool(v
, &value
, name
, errp
);
95 static void prop_set_bit(Object
*obj
, Visitor
*v
, void *opaque
,
96 const char *name
, Error
**errp
)
98 DeviceState
*dev
= DEVICE(obj
);
99 Property
*prop
= opaque
;
100 Error
*local_err
= NULL
;
104 qdev_prop_set_after_realize(dev
, name
, errp
);
108 visit_type_bool(v
, &value
, name
, &local_err
);
110 error_propagate(errp
, local_err
);
113 bit_prop_set(dev
, prop
, value
);
116 PropertyInfo qdev_prop_bit
= {
118 .legacy_name
= "on/off",
119 .print
= prop_print_bit
,
126 static void get_bool(Object
*obj
, Visitor
*v
, void *opaque
,
127 const char *name
, Error
**errp
)
129 DeviceState
*dev
= DEVICE(obj
);
130 Property
*prop
= opaque
;
131 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
133 visit_type_bool(v
, ptr
, name
, errp
);
136 static void set_bool(Object
*obj
, Visitor
*v
, void *opaque
,
137 const char *name
, Error
**errp
)
139 DeviceState
*dev
= DEVICE(obj
);
140 Property
*prop
= opaque
;
141 bool *ptr
= qdev_get_prop_ptr(dev
, prop
);
144 qdev_prop_set_after_realize(dev
, name
, errp
);
148 visit_type_bool(v
, ptr
, name
, errp
);
151 PropertyInfo qdev_prop_bool
= {
157 /* --- 8bit integer --- */
159 static void get_uint8(Object
*obj
, Visitor
*v
, void *opaque
,
160 const char *name
, Error
**errp
)
162 DeviceState
*dev
= DEVICE(obj
);
163 Property
*prop
= opaque
;
164 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
166 visit_type_uint8(v
, ptr
, name
, errp
);
169 static void set_uint8(Object
*obj
, Visitor
*v
, void *opaque
,
170 const char *name
, Error
**errp
)
172 DeviceState
*dev
= DEVICE(obj
);
173 Property
*prop
= opaque
;
174 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
177 qdev_prop_set_after_realize(dev
, name
, errp
);
181 visit_type_uint8(v
, ptr
, name
, errp
);
184 PropertyInfo qdev_prop_uint8
= {
190 /* --- 8bit hex value --- */
192 static int print_hex8(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
194 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
195 return snprintf(dest
, len
, "0x%" PRIx8
, *ptr
);
198 PropertyInfo qdev_prop_hex8
= {
200 .legacy_name
= "hex8",
206 /* --- 16bit integer --- */
208 static void get_uint16(Object
*obj
, Visitor
*v
, void *opaque
,
209 const char *name
, Error
**errp
)
211 DeviceState
*dev
= DEVICE(obj
);
212 Property
*prop
= opaque
;
213 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
215 visit_type_uint16(v
, ptr
, name
, errp
);
218 static void set_uint16(Object
*obj
, Visitor
*v
, void *opaque
,
219 const char *name
, Error
**errp
)
221 DeviceState
*dev
= DEVICE(obj
);
222 Property
*prop
= opaque
;
223 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
226 qdev_prop_set_after_realize(dev
, name
, errp
);
230 visit_type_uint16(v
, ptr
, name
, errp
);
233 PropertyInfo qdev_prop_uint16
= {
239 /* --- 32bit integer --- */
241 static void get_uint32(Object
*obj
, Visitor
*v
, void *opaque
,
242 const char *name
, Error
**errp
)
244 DeviceState
*dev
= DEVICE(obj
);
245 Property
*prop
= opaque
;
246 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
248 visit_type_uint32(v
, ptr
, name
, errp
);
251 static void set_uint32(Object
*obj
, Visitor
*v
, void *opaque
,
252 const char *name
, Error
**errp
)
254 DeviceState
*dev
= DEVICE(obj
);
255 Property
*prop
= opaque
;
256 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
259 qdev_prop_set_after_realize(dev
, name
, errp
);
263 visit_type_uint32(v
, ptr
, name
, errp
);
266 static void get_int32(Object
*obj
, Visitor
*v
, void *opaque
,
267 const char *name
, Error
**errp
)
269 DeviceState
*dev
= DEVICE(obj
);
270 Property
*prop
= opaque
;
271 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
273 visit_type_int32(v
, ptr
, name
, errp
);
276 static void set_int32(Object
*obj
, Visitor
*v
, void *opaque
,
277 const char *name
, Error
**errp
)
279 DeviceState
*dev
= DEVICE(obj
);
280 Property
*prop
= opaque
;
281 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
284 qdev_prop_set_after_realize(dev
, name
, errp
);
288 visit_type_int32(v
, ptr
, name
, errp
);
291 PropertyInfo qdev_prop_uint32
= {
297 PropertyInfo qdev_prop_int32
= {
303 /* --- 32bit hex value --- */
305 static int print_hex32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
307 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
308 return snprintf(dest
, len
, "0x%" PRIx32
, *ptr
);
311 PropertyInfo qdev_prop_hex32
= {
313 .legacy_name
= "hex32",
314 .print
= print_hex32
,
319 /* --- 64bit integer --- */
321 static void get_uint64(Object
*obj
, Visitor
*v
, void *opaque
,
322 const char *name
, Error
**errp
)
324 DeviceState
*dev
= DEVICE(obj
);
325 Property
*prop
= opaque
;
326 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
328 visit_type_uint64(v
, ptr
, name
, errp
);
331 static void set_uint64(Object
*obj
, Visitor
*v
, void *opaque
,
332 const char *name
, Error
**errp
)
334 DeviceState
*dev
= DEVICE(obj
);
335 Property
*prop
= opaque
;
336 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
339 qdev_prop_set_after_realize(dev
, name
, errp
);
343 visit_type_uint64(v
, ptr
, name
, errp
);
346 PropertyInfo qdev_prop_uint64
= {
352 /* --- 64bit hex value --- */
354 static int print_hex64(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
356 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
357 return snprintf(dest
, len
, "0x%" PRIx64
, *ptr
);
360 PropertyInfo qdev_prop_hex64
= {
362 .legacy_name
= "hex64",
363 .print
= print_hex64
,
370 static void release_string(Object
*obj
, const char *name
, void *opaque
)
372 Property
*prop
= opaque
;
373 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj
), prop
));
376 static int print_string(DeviceState
*dev
, Property
*prop
, char *dest
,
379 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
381 return snprintf(dest
, len
, "<null>");
383 return snprintf(dest
, len
, "\"%s\"", *ptr
);
386 static void get_string(Object
*obj
, Visitor
*v
, void *opaque
,
387 const char *name
, Error
**errp
)
389 DeviceState
*dev
= DEVICE(obj
);
390 Property
*prop
= opaque
;
391 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
394 char *str
= (char *)"";
395 visit_type_str(v
, &str
, name
, errp
);
397 visit_type_str(v
, ptr
, name
, errp
);
401 static void set_string(Object
*obj
, Visitor
*v
, void *opaque
,
402 const char *name
, Error
**errp
)
404 DeviceState
*dev
= DEVICE(obj
);
405 Property
*prop
= opaque
;
406 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
407 Error
*local_err
= NULL
;
411 qdev_prop_set_after_realize(dev
, name
, errp
);
415 visit_type_str(v
, &str
, name
, &local_err
);
417 error_propagate(errp
, local_err
);
426 PropertyInfo qdev_prop_string
= {
428 .print
= print_string
,
429 .release
= release_string
,
434 /* --- pointer --- */
436 /* Not a proper property, just for dirty hacks. TODO Remove it! */
437 PropertyInfo qdev_prop_ptr
= {
441 /* --- mac address --- */
444 * accepted syntax versions:
448 static void get_mac(Object
*obj
, Visitor
*v
, void *opaque
,
449 const char *name
, Error
**errp
)
451 DeviceState
*dev
= DEVICE(obj
);
452 Property
*prop
= opaque
;
453 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
454 char buffer
[2 * 6 + 5 + 1];
457 snprintf(buffer
, sizeof(buffer
), "%02x:%02x:%02x:%02x:%02x:%02x",
458 mac
->a
[0], mac
->a
[1], mac
->a
[2],
459 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
461 visit_type_str(v
, &p
, name
, errp
);
464 static void set_mac(Object
*obj
, Visitor
*v
, void *opaque
,
465 const char *name
, Error
**errp
)
467 DeviceState
*dev
= DEVICE(obj
);
468 Property
*prop
= opaque
;
469 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
470 Error
*local_err
= NULL
;
475 qdev_prop_set_after_realize(dev
, name
, errp
);
479 visit_type_str(v
, &str
, name
, &local_err
);
481 error_propagate(errp
, local_err
);
485 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
486 if (!qemu_isxdigit(str
[pos
])) {
489 if (!qemu_isxdigit(str
[pos
+1])) {
493 if (str
[pos
+2] != '\0') {
497 if (str
[pos
+2] != ':' && str
[pos
+2] != '-') {
501 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
507 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
511 PropertyInfo qdev_prop_macaddr
= {
517 /* --- lost tick policy --- */
519 static const char *lost_tick_policy_table
[LOST_TICK_MAX
+1] = {
520 [LOST_TICK_DISCARD
] = "discard",
521 [LOST_TICK_DELAY
] = "delay",
522 [LOST_TICK_MERGE
] = "merge",
523 [LOST_TICK_SLEW
] = "slew",
524 [LOST_TICK_MAX
] = NULL
,
527 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy
) != sizeof(int));
529 PropertyInfo qdev_prop_losttickpolicy
= {
530 .name
= "LostTickPolicy",
531 .enum_table
= lost_tick_policy_table
,
536 /* --- BIOS CHS translation */
538 static const char *bios_chs_trans_table
[] = {
539 [BIOS_ATA_TRANSLATION_AUTO
] = "auto",
540 [BIOS_ATA_TRANSLATION_NONE
] = "none",
541 [BIOS_ATA_TRANSLATION_LBA
] = "lba",
544 PropertyInfo qdev_prop_bios_chs_trans
= {
545 .name
= "bios-chs-trans",
546 .enum_table
= bios_chs_trans_table
,
551 /* --- pci address --- */
554 * bus-local address, i.e. "$slot" or "$slot.$fn"
556 static void set_pci_devfn(Object
*obj
, Visitor
*v
, void *opaque
,
557 const char *name
, Error
**errp
)
559 DeviceState
*dev
= DEVICE(obj
);
560 Property
*prop
= opaque
;
561 int32_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
562 unsigned int slot
, fn
, n
;
563 Error
*local_err
= NULL
;
567 qdev_prop_set_after_realize(dev
, name
, errp
);
571 visit_type_str(v
, &str
, name
, &local_err
);
573 error_free(local_err
);
575 visit_type_int32(v
, &value
, name
, &local_err
);
577 error_propagate(errp
, local_err
);
578 } else if (value
< -1 || value
> 255) {
579 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, name
? name
: "null",
587 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
589 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
593 if (str
[n
] != '\0' || fn
> 7 || slot
> 31) {
596 *ptr
= slot
<< 3 | fn
;
601 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
605 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
,
608 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
611 return snprintf(dest
, len
, "<unset>");
613 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
617 PropertyInfo qdev_prop_pci_devfn
= {
619 .legacy_name
= "pci-devfn",
620 .print
= print_pci_devfn
,
622 .set
= set_pci_devfn
,
625 /* --- blocksize --- */
627 static void set_blocksize(Object
*obj
, Visitor
*v
, void *opaque
,
628 const char *name
, Error
**errp
)
630 DeviceState
*dev
= DEVICE(obj
);
631 Property
*prop
= opaque
;
632 uint16_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
633 Error
*local_err
= NULL
;
634 const int64_t min
= 512;
635 const int64_t max
= 32768;
638 qdev_prop_set_after_realize(dev
, name
, errp
);
642 visit_type_uint16(v
, &value
, name
, &local_err
);
644 error_propagate(errp
, local_err
);
647 if (value
< min
|| value
> max
) {
648 error_set(errp
, QERR_PROPERTY_VALUE_OUT_OF_RANGE
,
649 dev
->id
?:"", name
, (int64_t)value
, min
, max
);
653 /* We rely on power-of-2 blocksizes for bitmasks */
654 if ((value
& (value
- 1)) != 0) {
655 error_set(errp
, QERR_PROPERTY_VALUE_NOT_POWER_OF_2
,
656 dev
->id
?:"", name
, (int64_t)value
);
663 PropertyInfo qdev_prop_blocksize
= {
666 .set
= set_blocksize
,
669 /* --- pci host address --- */
671 static void get_pci_host_devaddr(Object
*obj
, Visitor
*v
, void *opaque
,
672 const char *name
, Error
**errp
)
674 DeviceState
*dev
= DEVICE(obj
);
675 Property
*prop
= opaque
;
676 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
677 char buffer
[] = "xxxx:xx:xx.x";
681 rc
= snprintf(buffer
, sizeof(buffer
), "%04x:%02x:%02x.%d",
682 addr
->domain
, addr
->bus
, addr
->slot
, addr
->function
);
683 assert(rc
== sizeof(buffer
) - 1);
685 visit_type_str(v
, &p
, name
, errp
);
689 * Parse [<domain>:]<bus>:<slot>.<func>
690 * if <domain> is not supplied, it's assumed to be 0.
692 static void set_pci_host_devaddr(Object
*obj
, Visitor
*v
, void *opaque
,
693 const char *name
, Error
**errp
)
695 DeviceState
*dev
= DEVICE(obj
);
696 Property
*prop
= opaque
;
697 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
698 Error
*local_err
= NULL
;
702 unsigned long dom
= 0, bus
= 0;
703 unsigned int slot
= 0, func
= 0;
706 qdev_prop_set_after_realize(dev
, name
, errp
);
710 visit_type_str(v
, &str
, name
, &local_err
);
712 error_propagate(errp
, local_err
);
717 val
= strtoul(p
, &e
, 16);
718 if (e
== p
|| *e
!= ':') {
724 val
= strtoul(p
, &e
, 16);
732 val
= strtoul(p
, &e
, 16);
743 val
= strtoul(p
, &e
, 10);
749 if (dom
> 0xffff || bus
> 0xff || slot
> 0x1f || func
> 7) {
760 addr
->function
= func
;
766 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
770 PropertyInfo qdev_prop_pci_host_devaddr
= {
771 .name
= "pci-host-devaddr",
772 .get
= get_pci_host_devaddr
,
773 .set
= set_pci_host_devaddr
,
776 /* --- support for array properties --- */
778 /* Used as an opaque for the object properties we add for each
779 * array element. Note that the struct Property must be first
780 * in the struct so that a pointer to this works as the opaque
781 * for the underlying element's property hooks as well as for
782 * our own release callback.
785 struct Property prop
;
787 ObjectPropertyRelease
*release
;
788 } ArrayElementProperty
;
790 /* object property release callback for array element properties:
791 * we call the underlying element's property release hook, and
792 * then free the memory we allocated when we added the property.
794 static void array_element_release(Object
*obj
, const char *name
, void *opaque
)
796 ArrayElementProperty
*p
= opaque
;
798 p
->release(obj
, name
, opaque
);
804 static void set_prop_arraylen(Object
*obj
, Visitor
*v
, void *opaque
,
805 const char *name
, Error
**errp
)
807 /* Setter for the property which defines the length of a
808 * variable-sized property array. As well as actually setting the
809 * array-length field in the device struct, we have to create the
810 * array itself and dynamically add the corresponding properties.
812 DeviceState
*dev
= DEVICE(obj
);
813 Property
*prop
= opaque
;
814 uint32_t *alenptr
= qdev_get_prop_ptr(dev
, prop
);
815 void **arrayptr
= (void *)dev
+ prop
->arrayoffset
;
817 const char *arrayname
;
821 qdev_prop_set_after_realize(dev
, name
, errp
);
825 error_setg(errp
, "array size property %s may not be set more than once",
829 visit_type_uint32(v
, alenptr
, name
, errp
);
830 if (error_is_set(errp
)) {
837 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
838 * strip it off so we can get the name of the array itself.
840 assert(strncmp(name
, PROP_ARRAY_LEN_PREFIX
,
841 strlen(PROP_ARRAY_LEN_PREFIX
)) == 0);
842 arrayname
= name
+ strlen(PROP_ARRAY_LEN_PREFIX
);
844 /* Note that it is the responsibility of the individual device's deinit
845 * to free the array proper.
847 *arrayptr
= eltptr
= g_malloc0(*alenptr
* prop
->arrayfieldsize
);
848 for (i
= 0; i
< *alenptr
; i
++, eltptr
+= prop
->arrayfieldsize
) {
849 char *propname
= g_strdup_printf("%s[%d]", arrayname
, i
);
850 ArrayElementProperty
*arrayprop
= g_new0(ArrayElementProperty
, 1);
851 arrayprop
->release
= prop
->arrayinfo
->release
;
852 arrayprop
->propname
= propname
;
853 arrayprop
->prop
.info
= prop
->arrayinfo
;
854 arrayprop
->prop
.name
= propname
;
855 /* This ugly piece of pointer arithmetic sets up the offset so
856 * that when the underlying get/set hooks call qdev_get_prop_ptr
857 * they get the right answer despite the array element not actually
858 * being inside the device struct.
860 arrayprop
->prop
.offset
= eltptr
- (void *)dev
;
861 assert(qdev_get_prop_ptr(dev
, &arrayprop
->prop
) == eltptr
);
862 object_property_add(obj
, propname
,
863 arrayprop
->prop
.info
->name
,
864 arrayprop
->prop
.info
->get
,
865 arrayprop
->prop
.info
->set
,
866 array_element_release
,
868 if (error_is_set(errp
)) {
874 PropertyInfo qdev_prop_arraylen
= {
877 .set
= set_prop_arraylen
,
880 /* --- public helpers --- */
882 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
887 while (props
->name
) {
888 if (strcmp(props
->name
, name
) == 0) {
896 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
901 /* device properties */
902 class = object_get_class(OBJECT(dev
));
904 prop
= qdev_prop_walk(DEVICE_CLASS(class)->props
, name
);
908 class = object_class_get_parent(class);
909 } while (class != object_class_by_name(TYPE_DEVICE
));
914 void error_set_from_qdev_prop_error(Error
**errp
, int ret
, DeviceState
*dev
,
915 Property
*prop
, const char *value
)
919 error_set(errp
, QERR_PROPERTY_VALUE_IN_USE
,
920 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
924 error_set(errp
, QERR_PROPERTY_VALUE_BAD
,
925 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
928 error_set(errp
, QERR_PROPERTY_VALUE_NOT_FOUND
,
929 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
936 void qdev_prop_parse(DeviceState
*dev
, const char *name
, const char *value
,
939 object_property_parse(OBJECT(dev
), value
, name
, errp
);
942 void qdev_prop_set_bit(DeviceState
*dev
, const char *name
, bool value
)
944 object_property_set_bool(OBJECT(dev
), value
, name
, &error_abort
);
947 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
949 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
952 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
954 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
957 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
959 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
962 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
964 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
967 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
969 object_property_set_int(OBJECT(dev
), value
, name
, &error_abort
);
972 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, const char *value
)
974 object_property_set_str(OBJECT(dev
), value
, name
, &error_abort
);
977 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
, uint8_t *value
)
979 char str
[2 * 6 + 5 + 1];
980 snprintf(str
, sizeof(str
), "%02x:%02x:%02x:%02x:%02x:%02x",
981 value
[0], value
[1], value
[2], value
[3], value
[4], value
[5]);
983 object_property_set_str(OBJECT(dev
), str
, name
, &error_abort
);
986 void qdev_prop_set_enum(DeviceState
*dev
, const char *name
, int value
)
990 prop
= qdev_prop_find(dev
, name
);
991 object_property_set_str(OBJECT(dev
), prop
->info
->enum_table
[value
],
995 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
1000 prop
= qdev_prop_find(dev
, name
);
1001 assert(prop
&& prop
->info
== &qdev_prop_ptr
);
1002 ptr
= qdev_get_prop_ptr(dev
, prop
);
1006 static QTAILQ_HEAD(, GlobalProperty
) global_props
=
1007 QTAILQ_HEAD_INITIALIZER(global_props
);
1009 void qdev_prop_register_global(GlobalProperty
*prop
)
1011 QTAILQ_INSERT_TAIL(&global_props
, prop
, next
);
1014 void qdev_prop_register_global_list(GlobalProperty
*props
)
1018 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
1019 qdev_prop_register_global(props
+i
);
1023 void qdev_prop_set_globals_for_type(DeviceState
*dev
, const char *typename
,
1026 GlobalProperty
*prop
;
1028 QTAILQ_FOREACH(prop
, &global_props
, next
) {
1031 if (strcmp(typename
, prop
->driver
) != 0) {
1034 qdev_prop_parse(dev
, prop
->property
, prop
->value
, &err
);
1036 error_propagate(errp
, err
);
1042 void qdev_prop_set_globals(DeviceState
*dev
, Error
**errp
)
1044 ObjectClass
*class = object_get_class(OBJECT(dev
));
1049 qdev_prop_set_globals_for_type(dev
, object_class_get_name(class),
1052 error_propagate(errp
, err
);
1055 class = object_class_get_parent(class);
1059 /* --- 64bit unsigned int 'size' type --- */
1061 static void get_size(Object
*obj
, Visitor
*v
, void *opaque
,
1062 const char *name
, Error
**errp
)
1064 DeviceState
*dev
= DEVICE(obj
);
1065 Property
*prop
= opaque
;
1066 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
1068 visit_type_size(v
, ptr
, name
, errp
);
1071 static void set_size(Object
*obj
, Visitor
*v
, void *opaque
,
1072 const char *name
, Error
**errp
)
1074 DeviceState
*dev
= DEVICE(obj
);
1075 Property
*prop
= opaque
;
1076 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
1078 visit_type_size(v
, ptr
, name
, errp
);
1081 static int print_size(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
1083 static const char suffixes
[] = { 'B', 'K', 'M', 'G', 'T' };
1084 uint64_t div
, val
= *(uint64_t *)qdev_get_prop_ptr(dev
, prop
);
1087 /* Compute floor(log2(val)). */
1088 i
= 64 - clz64(val
);
1090 /* Find the power of 1024 that we'll display as the units. */
1092 if (i
>= ARRAY_SIZE(suffixes
)) {
1093 i
= ARRAY_SIZE(suffixes
) - 1;
1095 div
= 1ULL << (i
* 10);
1097 return snprintf(dest
, len
, "%0.03f%c", (double)val
/div
, suffixes
[i
]);
1100 PropertyInfo qdev_prop_size
= {
1102 .print
= print_size
,