5 #include "hw/block-common.h"
7 #include "qapi/qapi-visit-core.h"
9 void *qdev_get_prop_ptr(DeviceState
*dev
, Property
*prop
)
16 static void get_pointer(Object
*obj
, Visitor
*v
, Property
*prop
,
17 const char *(*print
)(void *ptr
),
18 const char *name
, Error
**errp
)
20 DeviceState
*dev
= DEVICE(obj
);
21 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
24 p
= (char *) (*ptr
? print(*ptr
) : "");
25 visit_type_str(v
, &p
, name
, errp
);
28 static void set_pointer(Object
*obj
, Visitor
*v
, Property
*prop
,
29 int (*parse
)(DeviceState
*dev
, const char *str
,
31 const char *name
, Error
**errp
)
33 DeviceState
*dev
= DEVICE(obj
);
34 Error
*local_err
= NULL
;
35 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
39 if (dev
->state
!= DEV_STATE_CREATED
) {
40 error_set(errp
, QERR_PERMISSION_DENIED
);
44 visit_type_str(v
, &str
, name
, &local_err
);
46 error_propagate(errp
, local_err
);
54 ret
= parse(dev
, str
, ptr
);
55 error_set_from_qdev_prop_error(errp
, ret
, dev
, prop
, str
);
59 static void get_enum(Object
*obj
, Visitor
*v
, void *opaque
,
60 const char *name
, Error
**errp
)
62 DeviceState
*dev
= DEVICE(obj
);
63 Property
*prop
= opaque
;
64 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
66 visit_type_enum(v
, ptr
, prop
->info
->enum_table
,
67 prop
->info
->name
, prop
->name
, errp
);
70 static void set_enum(Object
*obj
, Visitor
*v
, void *opaque
,
71 const char *name
, Error
**errp
)
73 DeviceState
*dev
= DEVICE(obj
);
74 Property
*prop
= opaque
;
75 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
77 if (dev
->state
!= DEV_STATE_CREATED
) {
78 error_set(errp
, QERR_PERMISSION_DENIED
);
82 visit_type_enum(v
, ptr
, prop
->info
->enum_table
,
83 prop
->info
->name
, prop
->name
, errp
);
88 static uint32_t qdev_get_prop_mask(Property
*prop
)
90 assert(prop
->info
== &qdev_prop_bit
);
91 return 0x1 << prop
->bitnr
;
94 static void bit_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
96 uint32_t *p
= qdev_get_prop_ptr(dev
, props
);
97 uint32_t mask
= qdev_get_prop_mask(props
);
104 static int print_bit(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
106 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
107 return snprintf(dest
, len
, (*p
& qdev_get_prop_mask(prop
)) ? "on" : "off");
110 static void get_bit(Object
*obj
, Visitor
*v
, void *opaque
,
111 const char *name
, Error
**errp
)
113 DeviceState
*dev
= DEVICE(obj
);
114 Property
*prop
= opaque
;
115 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
116 bool value
= (*p
& qdev_get_prop_mask(prop
)) != 0;
118 visit_type_bool(v
, &value
, name
, errp
);
121 static void set_bit(Object
*obj
, Visitor
*v
, void *opaque
,
122 const char *name
, Error
**errp
)
124 DeviceState
*dev
= DEVICE(obj
);
125 Property
*prop
= opaque
;
126 Error
*local_err
= NULL
;
129 if (dev
->state
!= DEV_STATE_CREATED
) {
130 error_set(errp
, QERR_PERMISSION_DENIED
);
134 visit_type_bool(v
, &value
, name
, &local_err
);
136 error_propagate(errp
, local_err
);
139 bit_prop_set(dev
, prop
, value
);
142 PropertyInfo qdev_prop_bit
= {
144 .legacy_name
= "on/off",
150 /* --- 8bit integer --- */
152 static void get_uint8(Object
*obj
, Visitor
*v
, void *opaque
,
153 const char *name
, Error
**errp
)
155 DeviceState
*dev
= DEVICE(obj
);
156 Property
*prop
= opaque
;
157 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
159 visit_type_uint8(v
, ptr
, name
, errp
);
162 static void set_uint8(Object
*obj
, Visitor
*v
, void *opaque
,
163 const char *name
, Error
**errp
)
165 DeviceState
*dev
= DEVICE(obj
);
166 Property
*prop
= opaque
;
167 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
169 if (dev
->state
!= DEV_STATE_CREATED
) {
170 error_set(errp
, QERR_PERMISSION_DENIED
);
174 visit_type_uint8(v
, ptr
, name
, errp
);
177 PropertyInfo qdev_prop_uint8
= {
183 /* --- 8bit hex value --- */
185 static int parse_hex8(DeviceState
*dev
, Property
*prop
, const char *str
)
187 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
190 if (str
[0] != '0' || str
[1] != 'x') {
194 *ptr
= strtoul(str
, &end
, 16);
195 if ((*end
!= '\0') || (end
== str
)) {
202 static int print_hex8(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
204 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
205 return snprintf(dest
, len
, "0x%" PRIx8
, *ptr
);
208 PropertyInfo qdev_prop_hex8
= {
210 .legacy_name
= "hex8",
217 /* --- 16bit integer --- */
219 static void get_uint16(Object
*obj
, Visitor
*v
, void *opaque
,
220 const char *name
, Error
**errp
)
222 DeviceState
*dev
= DEVICE(obj
);
223 Property
*prop
= opaque
;
224 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
226 visit_type_uint16(v
, ptr
, name
, errp
);
229 static void set_uint16(Object
*obj
, Visitor
*v
, void *opaque
,
230 const char *name
, Error
**errp
)
232 DeviceState
*dev
= DEVICE(obj
);
233 Property
*prop
= opaque
;
234 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
236 if (dev
->state
!= DEV_STATE_CREATED
) {
237 error_set(errp
, QERR_PERMISSION_DENIED
);
241 visit_type_uint16(v
, ptr
, name
, errp
);
244 PropertyInfo qdev_prop_uint16
= {
250 /* --- 32bit integer --- */
252 static void get_uint32(Object
*obj
, Visitor
*v
, void *opaque
,
253 const char *name
, Error
**errp
)
255 DeviceState
*dev
= DEVICE(obj
);
256 Property
*prop
= opaque
;
257 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
259 visit_type_uint32(v
, ptr
, name
, errp
);
262 static void set_uint32(Object
*obj
, Visitor
*v
, void *opaque
,
263 const char *name
, Error
**errp
)
265 DeviceState
*dev
= DEVICE(obj
);
266 Property
*prop
= opaque
;
267 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
269 if (dev
->state
!= DEV_STATE_CREATED
) {
270 error_set(errp
, QERR_PERMISSION_DENIED
);
274 visit_type_uint32(v
, ptr
, name
, errp
);
277 static void get_int32(Object
*obj
, Visitor
*v
, void *opaque
,
278 const char *name
, Error
**errp
)
280 DeviceState
*dev
= DEVICE(obj
);
281 Property
*prop
= opaque
;
282 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
284 visit_type_int32(v
, ptr
, name
, errp
);
287 static void set_int32(Object
*obj
, Visitor
*v
, void *opaque
,
288 const char *name
, Error
**errp
)
290 DeviceState
*dev
= DEVICE(obj
);
291 Property
*prop
= opaque
;
292 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
294 if (dev
->state
!= DEV_STATE_CREATED
) {
295 error_set(errp
, QERR_PERMISSION_DENIED
);
299 visit_type_int32(v
, ptr
, name
, errp
);
302 PropertyInfo qdev_prop_uint32
= {
308 PropertyInfo qdev_prop_int32
= {
314 /* --- 32bit hex value --- */
316 static int parse_hex32(DeviceState
*dev
, Property
*prop
, const char *str
)
318 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
321 if (str
[0] != '0' || str
[1] != 'x') {
325 *ptr
= strtoul(str
, &end
, 16);
326 if ((*end
!= '\0') || (end
== str
)) {
333 static int print_hex32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
335 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
336 return snprintf(dest
, len
, "0x%" PRIx32
, *ptr
);
339 PropertyInfo qdev_prop_hex32
= {
341 .legacy_name
= "hex32",
342 .parse
= parse_hex32
,
343 .print
= print_hex32
,
348 /* --- 64bit integer --- */
350 static void get_uint64(Object
*obj
, Visitor
*v
, void *opaque
,
351 const char *name
, Error
**errp
)
353 DeviceState
*dev
= DEVICE(obj
);
354 Property
*prop
= opaque
;
355 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
357 visit_type_uint64(v
, ptr
, name
, errp
);
360 static void set_uint64(Object
*obj
, Visitor
*v
, void *opaque
,
361 const char *name
, Error
**errp
)
363 DeviceState
*dev
= DEVICE(obj
);
364 Property
*prop
= opaque
;
365 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
367 if (dev
->state
!= DEV_STATE_CREATED
) {
368 error_set(errp
, QERR_PERMISSION_DENIED
);
372 visit_type_uint64(v
, ptr
, name
, errp
);
375 PropertyInfo qdev_prop_uint64
= {
381 /* --- 64bit hex value --- */
383 static int parse_hex64(DeviceState
*dev
, Property
*prop
, const char *str
)
385 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
388 if (str
[0] != '0' || str
[1] != 'x') {
392 *ptr
= strtoull(str
, &end
, 16);
393 if ((*end
!= '\0') || (end
== str
)) {
400 static int print_hex64(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
402 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
403 return snprintf(dest
, len
, "0x%" PRIx64
, *ptr
);
406 PropertyInfo qdev_prop_hex64
= {
408 .legacy_name
= "hex64",
409 .parse
= parse_hex64
,
410 .print
= print_hex64
,
417 static void release_string(Object
*obj
, const char *name
, void *opaque
)
419 Property
*prop
= opaque
;
420 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj
), prop
));
423 static int print_string(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
425 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
427 return snprintf(dest
, len
, "<null>");
428 return snprintf(dest
, len
, "\"%s\"", *ptr
);
431 static void get_string(Object
*obj
, Visitor
*v
, void *opaque
,
432 const char *name
, Error
**errp
)
434 DeviceState
*dev
= DEVICE(obj
);
435 Property
*prop
= opaque
;
436 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
439 char *str
= (char *)"";
440 visit_type_str(v
, &str
, name
, errp
);
442 visit_type_str(v
, ptr
, name
, errp
);
446 static void set_string(Object
*obj
, Visitor
*v
, void *opaque
,
447 const char *name
, Error
**errp
)
449 DeviceState
*dev
= DEVICE(obj
);
450 Property
*prop
= opaque
;
451 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
452 Error
*local_err
= NULL
;
455 if (dev
->state
!= DEV_STATE_CREATED
) {
456 error_set(errp
, QERR_PERMISSION_DENIED
);
460 visit_type_str(v
, &str
, name
, &local_err
);
462 error_propagate(errp
, local_err
);
471 PropertyInfo qdev_prop_string
= {
473 .print
= print_string
,
474 .release
= release_string
,
481 static int parse_drive(DeviceState
*dev
, const char *str
, void **ptr
)
483 BlockDriverState
*bs
;
488 if (bdrv_attach_dev(bs
, dev
) < 0)
494 static void release_drive(Object
*obj
, const char *name
, void *opaque
)
496 DeviceState
*dev
= DEVICE(obj
);
497 Property
*prop
= opaque
;
498 BlockDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
501 bdrv_detach_dev(*ptr
, dev
);
502 blockdev_auto_del(*ptr
);
506 static const char *print_drive(void *ptr
)
508 return bdrv_get_device_name(ptr
);
511 static void get_drive(Object
*obj
, Visitor
*v
, void *opaque
,
512 const char *name
, Error
**errp
)
514 get_pointer(obj
, v
, opaque
, print_drive
, name
, errp
);
517 static void set_drive(Object
*obj
, Visitor
*v
, void *opaque
,
518 const char *name
, Error
**errp
)
520 set_pointer(obj
, v
, opaque
, parse_drive
, name
, errp
);
523 PropertyInfo qdev_prop_drive
= {
527 .release
= release_drive
,
530 /* --- character device --- */
532 static int parse_chr(DeviceState
*dev
, const char *str
, void **ptr
)
534 CharDriverState
*chr
= qemu_chr_find(str
);
538 if (chr
->avail_connections
< 1) {
542 --chr
->avail_connections
;
546 static void release_chr(Object
*obj
, const char *name
, void *opaque
)
548 DeviceState
*dev
= DEVICE(obj
);
549 Property
*prop
= opaque
;
550 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
553 qemu_chr_add_handlers(*ptr
, NULL
, NULL
, NULL
, NULL
);
558 static const char *print_chr(void *ptr
)
560 CharDriverState
*chr
= ptr
;
562 return chr
->label
? chr
->label
: "";
565 static void get_chr(Object
*obj
, Visitor
*v
, void *opaque
,
566 const char *name
, Error
**errp
)
568 get_pointer(obj
, v
, opaque
, print_chr
, name
, errp
);
571 static void set_chr(Object
*obj
, Visitor
*v
, void *opaque
,
572 const char *name
, Error
**errp
)
574 set_pointer(obj
, v
, opaque
, parse_chr
, name
, errp
);
577 PropertyInfo qdev_prop_chr
= {
581 .release
= release_chr
,
584 /* --- netdev device --- */
586 static int parse_netdev(DeviceState
*dev
, const char *str
, void **ptr
)
588 NetClientState
*netdev
= qemu_find_netdev(str
);
590 if (netdev
== NULL
) {
600 static const char *print_netdev(void *ptr
)
602 NetClientState
*netdev
= ptr
;
604 return netdev
->name
? netdev
->name
: "";
607 static void get_netdev(Object
*obj
, Visitor
*v
, void *opaque
,
608 const char *name
, Error
**errp
)
610 get_pointer(obj
, v
, opaque
, print_netdev
, name
, errp
);
613 static void set_netdev(Object
*obj
, Visitor
*v
, void *opaque
,
614 const char *name
, Error
**errp
)
616 set_pointer(obj
, v
, opaque
, parse_netdev
, name
, errp
);
619 PropertyInfo qdev_prop_netdev
= {
627 static int print_vlan(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
629 NetClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
633 if (!net_hub_id_for_client(*ptr
, &id
)) {
634 return snprintf(dest
, len
, "%d", id
);
638 return snprintf(dest
, len
, "<null>");
641 static void get_vlan(Object
*obj
, Visitor
*v
, void *opaque
,
642 const char *name
, Error
**errp
)
644 DeviceState
*dev
= DEVICE(obj
);
645 Property
*prop
= opaque
;
646 NetClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
651 if (!net_hub_id_for_client(*ptr
, &hub_id
)) {
656 visit_type_int32(v
, &id
, name
, errp
);
659 static void set_vlan(Object
*obj
, Visitor
*v
, void *opaque
,
660 const char *name
, Error
**errp
)
662 DeviceState
*dev
= DEVICE(obj
);
663 Property
*prop
= opaque
;
664 NetClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
665 Error
*local_err
= NULL
;
667 NetClientState
*hubport
;
669 if (dev
->state
!= DEV_STATE_CREATED
) {
670 error_set(errp
, QERR_PERMISSION_DENIED
);
674 visit_type_int32(v
, &id
, name
, &local_err
);
676 error_propagate(errp
, local_err
);
684 hubport
= net_hub_port_find(id
);
686 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
,
687 name
, prop
->info
->name
);
693 PropertyInfo qdev_prop_vlan
= {
700 /* --- pointer --- */
702 /* Not a proper property, just for dirty hacks. TODO Remove it! */
703 PropertyInfo qdev_prop_ptr
= {
707 /* --- mac address --- */
710 * accepted syntax versions:
714 static void get_mac(Object
*obj
, Visitor
*v
, void *opaque
,
715 const char *name
, Error
**errp
)
717 DeviceState
*dev
= DEVICE(obj
);
718 Property
*prop
= opaque
;
719 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
720 char buffer
[2 * 6 + 5 + 1];
723 snprintf(buffer
, sizeof(buffer
), "%02x:%02x:%02x:%02x:%02x:%02x",
724 mac
->a
[0], mac
->a
[1], mac
->a
[2],
725 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
727 visit_type_str(v
, &p
, name
, errp
);
730 static void set_mac(Object
*obj
, Visitor
*v
, void *opaque
,
731 const char *name
, Error
**errp
)
733 DeviceState
*dev
= DEVICE(obj
);
734 Property
*prop
= opaque
;
735 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
736 Error
*local_err
= NULL
;
740 if (dev
->state
!= DEV_STATE_CREATED
) {
741 error_set(errp
, QERR_PERMISSION_DENIED
);
745 visit_type_str(v
, &str
, name
, &local_err
);
747 error_propagate(errp
, local_err
);
751 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
752 if (!qemu_isxdigit(str
[pos
]))
754 if (!qemu_isxdigit(str
[pos
+1]))
757 if (str
[pos
+2] != '\0')
760 if (str
[pos
+2] != ':' && str
[pos
+2] != '-')
763 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
769 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
773 PropertyInfo qdev_prop_macaddr
= {
779 /* --- lost tick policy --- */
781 static const char *lost_tick_policy_table
[LOST_TICK_MAX
+1] = {
782 [LOST_TICK_DISCARD
] = "discard",
783 [LOST_TICK_DELAY
] = "delay",
784 [LOST_TICK_MERGE
] = "merge",
785 [LOST_TICK_SLEW
] = "slew",
786 [LOST_TICK_MAX
] = NULL
,
789 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy
) != sizeof(int));
791 PropertyInfo qdev_prop_losttickpolicy
= {
792 .name
= "LostTickPolicy",
793 .enum_table
= lost_tick_policy_table
,
798 /* --- BIOS CHS translation */
800 static const char *bios_chs_trans_table
[] = {
801 [BIOS_ATA_TRANSLATION_AUTO
] = "auto",
802 [BIOS_ATA_TRANSLATION_NONE
] = "none",
803 [BIOS_ATA_TRANSLATION_LBA
] = "lba",
806 PropertyInfo qdev_prop_bios_chs_trans
= {
807 .name
= "bios-chs-trans",
808 .enum_table
= bios_chs_trans_table
,
813 /* --- pci address --- */
816 * bus-local address, i.e. "$slot" or "$slot.$fn"
818 static void set_pci_devfn(Object
*obj
, Visitor
*v
, void *opaque
,
819 const char *name
, Error
**errp
)
821 DeviceState
*dev
= DEVICE(obj
);
822 Property
*prop
= opaque
;
823 int32_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
824 unsigned int slot
, fn
, n
;
825 Error
*local_err
= NULL
;
828 if (dev
->state
!= DEV_STATE_CREATED
) {
829 error_set(errp
, QERR_PERMISSION_DENIED
);
833 visit_type_str(v
, &str
, name
, &local_err
);
835 error_free(local_err
);
837 visit_type_int32(v
, &value
, name
, &local_err
);
839 error_propagate(errp
, local_err
);
840 } else if (value
< -1 || value
> 255) {
841 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, name
? name
: "null",
849 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
851 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
855 if (str
[n
] != '\0' || fn
> 7 || slot
> 31) {
858 *ptr
= slot
<< 3 | fn
;
863 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
867 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
869 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
872 return snprintf(dest
, len
, "<unset>");
874 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
878 PropertyInfo qdev_prop_pci_devfn
= {
880 .legacy_name
= "pci-devfn",
881 .print
= print_pci_devfn
,
883 .set
= set_pci_devfn
,
886 /* --- blocksize --- */
888 static void set_blocksize(Object
*obj
, Visitor
*v
, void *opaque
,
889 const char *name
, Error
**errp
)
891 DeviceState
*dev
= DEVICE(obj
);
892 Property
*prop
= opaque
;
893 uint16_t value
, *ptr
= qdev_get_prop_ptr(dev
, prop
);
894 Error
*local_err
= NULL
;
895 const int64_t min
= 512;
896 const int64_t max
= 32768;
898 if (dev
->state
!= DEV_STATE_CREATED
) {
899 error_set(errp
, QERR_PERMISSION_DENIED
);
903 visit_type_uint16(v
, &value
, name
, &local_err
);
905 error_propagate(errp
, local_err
);
908 if (value
< min
|| value
> max
) {
909 error_set(errp
, QERR_PROPERTY_VALUE_OUT_OF_RANGE
,
910 dev
->id
?:"", name
, (int64_t)value
, min
, max
);
914 /* We rely on power-of-2 blocksizes for bitmasks */
915 if ((value
& (value
- 1)) != 0) {
916 error_set(errp
, QERR_PROPERTY_VALUE_NOT_POWER_OF_2
,
917 dev
->id
?:"", name
, (int64_t)value
);
924 PropertyInfo qdev_prop_blocksize
= {
927 .set
= set_blocksize
,
930 /* --- pci host address --- */
932 static void get_pci_host_devaddr(Object
*obj
, Visitor
*v
, void *opaque
,
933 const char *name
, Error
**errp
)
935 DeviceState
*dev
= DEVICE(obj
);
936 Property
*prop
= opaque
;
937 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
938 char buffer
[] = "xxxx:xx:xx.x";
942 rc
= snprintf(buffer
, sizeof(buffer
), "%04x:%02x:%02x.%d",
943 addr
->domain
, addr
->bus
, addr
->slot
, addr
->function
);
944 assert(rc
== sizeof(buffer
) - 1);
946 visit_type_str(v
, &p
, name
, errp
);
950 * Parse [<domain>:]<bus>:<slot>.<func>
951 * if <domain> is not supplied, it's assumed to be 0.
953 static void set_pci_host_devaddr(Object
*obj
, Visitor
*v
, void *opaque
,
954 const char *name
, Error
**errp
)
956 DeviceState
*dev
= DEVICE(obj
);
957 Property
*prop
= opaque
;
958 PCIHostDeviceAddress
*addr
= qdev_get_prop_ptr(dev
, prop
);
959 Error
*local_err
= NULL
;
963 unsigned long dom
= 0, bus
= 0;
964 unsigned int slot
= 0, func
= 0;
966 if (dev
->state
!= DEV_STATE_CREATED
) {
967 error_set(errp
, QERR_PERMISSION_DENIED
);
971 visit_type_str(v
, &str
, name
, &local_err
);
973 error_propagate(errp
, local_err
);
978 val
= strtoul(p
, &e
, 16);
979 if (e
== p
|| *e
!= ':') {
985 val
= strtoul(p
, &e
, 16);
993 val
= strtoul(p
, &e
, 16);
1004 val
= strtoul(p
, &e
, 10);
1010 if (dom
> 0xffff || bus
> 0xff || slot
> 0x1f || func
> 7) {
1021 addr
->function
= func
;
1027 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
1031 PropertyInfo qdev_prop_pci_host_devaddr
= {
1032 .name
= "pci-host-devaddr",
1033 .get
= get_pci_host_devaddr
,
1034 .set
= set_pci_host_devaddr
,
1037 /* --- public helpers --- */
1039 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
1043 while (props
->name
) {
1044 if (strcmp(props
->name
, name
) == 0)
1051 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
1056 /* device properties */
1057 class = object_get_class(OBJECT(dev
));
1059 prop
= qdev_prop_walk(DEVICE_CLASS(class)->props
, name
);
1063 class = object_class_get_parent(class);
1064 } while (class != object_class_by_name(TYPE_DEVICE
));
1069 void error_set_from_qdev_prop_error(Error
**errp
, int ret
, DeviceState
*dev
,
1070 Property
*prop
, const char *value
)
1074 error_set(errp
, QERR_PROPERTY_VALUE_IN_USE
,
1075 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1079 error_set(errp
, QERR_PROPERTY_VALUE_BAD
,
1080 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1083 error_set(errp
, QERR_PROPERTY_VALUE_NOT_FOUND
,
1084 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1091 int qdev_prop_parse(DeviceState
*dev
, const char *name
, const char *value
)
1096 legacy_name
= g_strdup_printf("legacy-%s", name
);
1097 if (object_property_get_type(OBJECT(dev
), legacy_name
, NULL
)) {
1098 object_property_parse(OBJECT(dev
), value
, legacy_name
, &err
);
1100 object_property_parse(OBJECT(dev
), value
, name
, &err
);
1102 g_free(legacy_name
);
1105 qerror_report_err(err
);
1112 void qdev_prop_set_bit(DeviceState
*dev
, const char *name
, bool value
)
1115 object_property_set_bool(OBJECT(dev
), value
, name
, &errp
);
1116 assert_no_error(errp
);
1119 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
1122 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1123 assert_no_error(errp
);
1126 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
1129 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1130 assert_no_error(errp
);
1133 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
1136 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1137 assert_no_error(errp
);
1140 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
1143 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1144 assert_no_error(errp
);
1147 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
1150 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1151 assert_no_error(errp
);
1154 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, const char *value
)
1157 object_property_set_str(OBJECT(dev
), value
, name
, &errp
);
1158 assert_no_error(errp
);
1161 int qdev_prop_set_drive(DeviceState
*dev
, const char *name
, BlockDriverState
*value
)
1164 const char *bdrv_name
= value
? bdrv_get_device_name(value
) : "";
1165 object_property_set_str(OBJECT(dev
), bdrv_name
,
1168 qerror_report_err(errp
);
1175 void qdev_prop_set_drive_nofail(DeviceState
*dev
, const char *name
, BlockDriverState
*value
)
1177 if (qdev_prop_set_drive(dev
, name
, value
) < 0) {
1181 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
, CharDriverState
*value
)
1184 assert(!value
|| value
->label
);
1185 object_property_set_str(OBJECT(dev
),
1186 value
? value
->label
: "", name
, &errp
);
1187 assert_no_error(errp
);
1190 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
, NetClientState
*value
)
1193 assert(!value
|| value
->name
);
1194 object_property_set_str(OBJECT(dev
),
1195 value
? value
->name
: "", name
, &errp
);
1196 assert_no_error(errp
);
1199 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
, uint8_t *value
)
1202 char str
[2 * 6 + 5 + 1];
1203 snprintf(str
, sizeof(str
), "%02x:%02x:%02x:%02x:%02x:%02x",
1204 value
[0], value
[1], value
[2], value
[3], value
[4], value
[5]);
1206 object_property_set_str(OBJECT(dev
), str
, name
, &errp
);
1207 assert_no_error(errp
);
1210 void qdev_prop_set_enum(DeviceState
*dev
, const char *name
, int value
)
1215 prop
= qdev_prop_find(dev
, name
);
1216 object_property_set_str(OBJECT(dev
), prop
->info
->enum_table
[value
],
1218 assert_no_error(errp
);
1221 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
1226 prop
= qdev_prop_find(dev
, name
);
1227 assert(prop
&& prop
->info
== &qdev_prop_ptr
);
1228 ptr
= qdev_get_prop_ptr(dev
, prop
);
1232 static QTAILQ_HEAD(, GlobalProperty
) global_props
= QTAILQ_HEAD_INITIALIZER(global_props
);
1234 static void qdev_prop_register_global(GlobalProperty
*prop
)
1236 QTAILQ_INSERT_TAIL(&global_props
, prop
, next
);
1239 void qdev_prop_register_global_list(GlobalProperty
*props
)
1243 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
1244 qdev_prop_register_global(props
+i
);
1248 void qdev_prop_set_globals(DeviceState
*dev
)
1250 ObjectClass
*class = object_get_class(OBJECT(dev
));
1253 GlobalProperty
*prop
;
1254 QTAILQ_FOREACH(prop
, &global_props
, next
) {
1255 if (strcmp(object_class_get_name(class), prop
->driver
) != 0) {
1258 if (qdev_prop_parse(dev
, prop
->property
, prop
->value
) != 0) {
1262 class = object_class_get_parent(class);
1266 static int qdev_add_one_global(QemuOpts
*opts
, void *opaque
)
1270 g
= g_malloc0(sizeof(*g
));
1271 g
->driver
= qemu_opt_get(opts
, "driver");
1272 g
->property
= qemu_opt_get(opts
, "property");
1273 g
->value
= qemu_opt_get(opts
, "value");
1274 qdev_prop_register_global(g
);
1278 void qemu_add_globals(void)
1280 qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global
, NULL
, 0);