6 void *qdev_get_prop_ptr(DeviceState
*dev
, Property
*prop
)
13 static uint32_t qdev_get_prop_mask(Property
*prop
)
15 assert(prop
->info
== &qdev_prop_bit
);
16 return 0x1 << prop
->bitnr
;
19 static void bit_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
21 uint32_t *p
= qdev_get_prop_ptr(dev
, props
);
22 uint32_t mask
= qdev_get_prop_mask(props
);
30 static int parse_bit(DeviceState
*dev
, Property
*prop
, const char *str
)
32 if (!strcasecmp(str
, "on"))
33 bit_prop_set(dev
, prop
, true);
34 else if (!strcasecmp(str
, "off"))
35 bit_prop_set(dev
, prop
, false);
41 static int print_bit(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
43 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
44 return snprintf(dest
, len
, (*p
& qdev_get_prop_mask(prop
)) ? "on" : "off");
47 static void get_bit(Object
*obj
, Visitor
*v
, void *opaque
,
48 const char *name
, Error
**errp
)
50 DeviceState
*dev
= DEVICE(obj
);
51 Property
*prop
= opaque
;
52 uint32_t *p
= qdev_get_prop_ptr(dev
, prop
);
53 bool value
= (*p
& qdev_get_prop_mask(prop
)) != 0;
55 visit_type_bool(v
, &value
, name
, errp
);
58 static void set_bit(Object
*obj
, Visitor
*v
, void *opaque
,
59 const char *name
, Error
**errp
)
61 DeviceState
*dev
= DEVICE(obj
);
62 Property
*prop
= opaque
;
63 Error
*local_err
= NULL
;
66 if (dev
->state
!= DEV_STATE_CREATED
) {
67 error_set(errp
, QERR_PERMISSION_DENIED
);
71 visit_type_bool(v
, &value
, name
, &local_err
);
73 error_propagate(errp
, local_err
);
76 bit_prop_set(dev
, prop
, value
);
79 PropertyInfo qdev_prop_bit
= {
81 .legacy_name
= "on/off",
88 /* --- 8bit integer --- */
90 static int parse_uint8(DeviceState
*dev
, Property
*prop
, const char *str
)
92 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
95 /* accept both hex and decimal */
96 *ptr
= strtoul(str
, &end
, 0);
97 if ((*end
!= '\0') || (end
== str
)) {
104 static int print_uint8(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
106 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
107 return snprintf(dest
, len
, "%" PRIu8
, *ptr
);
110 static void get_int8(Object
*obj
, Visitor
*v
, void *opaque
,
111 const char *name
, Error
**errp
)
113 DeviceState
*dev
= DEVICE(obj
);
114 Property
*prop
= opaque
;
115 int8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
119 visit_type_int(v
, &value
, name
, errp
);
122 static void set_int8(Object
*obj
, Visitor
*v
, void *opaque
,
123 const char *name
, Error
**errp
)
125 DeviceState
*dev
= DEVICE(obj
);
126 Property
*prop
= opaque
;
127 int8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
128 Error
*local_err
= NULL
;
131 if (dev
->state
!= DEV_STATE_CREATED
) {
132 error_set(errp
, QERR_PERMISSION_DENIED
);
136 visit_type_int(v
, &value
, name
, &local_err
);
138 error_propagate(errp
, local_err
);
141 if (value
>= prop
->info
->min
&& value
<= prop
->info
->max
) {
144 error_set(errp
, QERR_PROPERTY_VALUE_OUT_OF_RANGE
,
145 dev
->id
?:"", name
, value
, prop
->info
->min
,
150 PropertyInfo qdev_prop_uint8
= {
152 .parse
= parse_uint8
,
153 .print
= print_uint8
,
160 /* --- 8bit hex value --- */
162 static int parse_hex8(DeviceState
*dev
, Property
*prop
, const char *str
)
164 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
167 *ptr
= strtoul(str
, &end
, 16);
168 if ((*end
!= '\0') || (end
== str
)) {
175 static int print_hex8(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
177 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
178 return snprintf(dest
, len
, "0x%" PRIx8
, *ptr
);
181 PropertyInfo qdev_prop_hex8
= {
183 .legacy_name
= "hex8",
192 /* --- 16bit integer --- */
194 static int parse_uint16(DeviceState
*dev
, Property
*prop
, const char *str
)
196 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
199 /* accept both hex and decimal */
200 *ptr
= strtoul(str
, &end
, 0);
201 if ((*end
!= '\0') || (end
== str
)) {
208 static int print_uint16(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
210 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
211 return snprintf(dest
, len
, "%" PRIu16
, *ptr
);
214 static void get_int16(Object
*obj
, Visitor
*v
, void *opaque
,
215 const char *name
, Error
**errp
)
217 DeviceState
*dev
= DEVICE(obj
);
218 Property
*prop
= opaque
;
219 int16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
223 visit_type_int(v
, &value
, name
, errp
);
226 static void set_int16(Object
*obj
, Visitor
*v
, void *opaque
,
227 const char *name
, Error
**errp
)
229 DeviceState
*dev
= DEVICE(obj
);
230 Property
*prop
= opaque
;
231 int16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
232 Error
*local_err
= NULL
;
235 if (dev
->state
!= DEV_STATE_CREATED
) {
236 error_set(errp
, QERR_PERMISSION_DENIED
);
240 visit_type_int(v
, &value
, name
, &local_err
);
242 error_propagate(errp
, local_err
);
245 if (value
>= prop
->info
->min
&& value
<= prop
->info
->max
) {
248 error_set(errp
, QERR_PROPERTY_VALUE_OUT_OF_RANGE
,
249 dev
->id
?:"", name
, value
, prop
->info
->min
,
254 PropertyInfo qdev_prop_uint16
= {
256 .parse
= parse_uint16
,
257 .print
= print_uint16
,
264 /* --- 32bit integer --- */
266 static int parse_uint32(DeviceState
*dev
, Property
*prop
, const char *str
)
268 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
271 /* accept both hex and decimal */
272 *ptr
= strtoul(str
, &end
, 0);
273 if ((*end
!= '\0') || (end
== str
)) {
280 static int print_uint32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
282 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
283 return snprintf(dest
, len
, "%" PRIu32
, *ptr
);
286 static void get_int32(Object
*obj
, Visitor
*v
, void *opaque
,
287 const char *name
, Error
**errp
)
289 DeviceState
*dev
= DEVICE(obj
);
290 Property
*prop
= opaque
;
291 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
295 visit_type_int(v
, &value
, name
, errp
);
298 static void set_int32(Object
*obj
, Visitor
*v
, void *opaque
,
299 const char *name
, Error
**errp
)
301 DeviceState
*dev
= DEVICE(obj
);
302 Property
*prop
= opaque
;
303 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
304 Error
*local_err
= NULL
;
307 if (dev
->state
!= DEV_STATE_CREATED
) {
308 error_set(errp
, QERR_PERMISSION_DENIED
);
312 visit_type_int(v
, &value
, name
, &local_err
);
314 error_propagate(errp
, local_err
);
317 if (value
>= prop
->info
->min
&& value
<= prop
->info
->max
) {
320 error_set(errp
, QERR_PROPERTY_VALUE_OUT_OF_RANGE
,
321 dev
->id
?:"", name
, value
, prop
->info
->min
,
326 PropertyInfo qdev_prop_uint32
= {
328 .parse
= parse_uint32
,
329 .print
= print_uint32
,
333 .max
= 0xFFFFFFFFULL
,
336 static int parse_int32(DeviceState
*dev
, Property
*prop
, const char *str
)
338 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
341 *ptr
= strtol(str
, &end
, 10);
342 if ((*end
!= '\0') || (end
== str
)) {
349 static int print_int32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
351 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
352 return snprintf(dest
, len
, "%" PRId32
, *ptr
);
355 PropertyInfo qdev_prop_int32
= {
357 .parse
= parse_int32
,
358 .print
= print_int32
,
361 .min
= -0x80000000LL
,
365 /* --- 32bit hex value --- */
367 static int parse_hex32(DeviceState
*dev
, Property
*prop
, const char *str
)
369 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
372 *ptr
= strtoul(str
, &end
, 16);
373 if ((*end
!= '\0') || (end
== str
)) {
380 static int print_hex32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
382 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
383 return snprintf(dest
, len
, "0x%" PRIx32
, *ptr
);
386 PropertyInfo qdev_prop_hex32
= {
388 .legacy_name
= "hex32",
389 .parse
= parse_hex32
,
390 .print
= print_hex32
,
394 .max
= 0xFFFFFFFFULL
,
397 /* --- 64bit integer --- */
399 static int parse_uint64(DeviceState
*dev
, Property
*prop
, const char *str
)
401 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
404 /* accept both hex and decimal */
405 *ptr
= strtoull(str
, &end
, 0);
406 if ((*end
!= '\0') || (end
== str
)) {
413 static int print_uint64(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
415 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
416 return snprintf(dest
, len
, "%" PRIu64
, *ptr
);
419 static void get_int64(Object
*obj
, Visitor
*v
, void *opaque
,
420 const char *name
, Error
**errp
)
422 DeviceState
*dev
= DEVICE(obj
);
423 Property
*prop
= opaque
;
424 int64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
426 visit_type_int(v
, ptr
, name
, errp
);
429 static void set_int64(Object
*obj
, Visitor
*v
, void *opaque
,
430 const char *name
, Error
**errp
)
432 DeviceState
*dev
= DEVICE(obj
);
433 Property
*prop
= opaque
;
434 int64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
436 if (dev
->state
!= DEV_STATE_CREATED
) {
437 error_set(errp
, QERR_PERMISSION_DENIED
);
441 visit_type_int(v
, ptr
, name
, errp
);
444 PropertyInfo qdev_prop_uint64
= {
446 .parse
= parse_uint64
,
447 .print
= print_uint64
,
452 /* --- 64bit hex value --- */
454 static int parse_hex64(DeviceState
*dev
, Property
*prop
, const char *str
)
456 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
459 *ptr
= strtoull(str
, &end
, 16);
460 if ((*end
!= '\0') || (end
== str
)) {
467 static int print_hex64(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
469 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
470 return snprintf(dest
, len
, "0x%" PRIx64
, *ptr
);
473 PropertyInfo qdev_prop_hex64
= {
475 .legacy_name
= "hex64",
476 .parse
= parse_hex64
,
477 .print
= print_hex64
,
484 static void release_string(Object
*obj
, const char *name
, void *opaque
)
486 Property
*prop
= opaque
;
487 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj
), prop
));
490 static int print_string(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
492 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
494 return snprintf(dest
, len
, "<null>");
495 return snprintf(dest
, len
, "\"%s\"", *ptr
);
498 static void get_string(Object
*obj
, Visitor
*v
, void *opaque
,
499 const char *name
, Error
**errp
)
501 DeviceState
*dev
= DEVICE(obj
);
502 Property
*prop
= opaque
;
503 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
506 char *str
= (char *)"";
507 visit_type_str(v
, &str
, name
, errp
);
509 visit_type_str(v
, ptr
, name
, errp
);
513 static void set_string(Object
*obj
, Visitor
*v
, void *opaque
,
514 const char *name
, Error
**errp
)
516 DeviceState
*dev
= DEVICE(obj
);
517 Property
*prop
= opaque
;
518 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
519 Error
*local_err
= NULL
;
522 if (dev
->state
!= DEV_STATE_CREATED
) {
523 error_set(errp
, QERR_PERMISSION_DENIED
);
527 visit_type_str(v
, &str
, name
, &local_err
);
529 error_propagate(errp
, local_err
);
542 PropertyInfo qdev_prop_string
= {
544 .print
= print_string
,
545 .release
= release_string
,
552 static int parse_drive(DeviceState
*dev
, const char *str
, void **ptr
)
554 BlockDriverState
*bs
;
559 if (bdrv_attach_dev(bs
, dev
) < 0)
565 static void release_drive(Object
*obj
, const char *name
, void *opaque
)
567 DeviceState
*dev
= DEVICE(obj
);
568 Property
*prop
= opaque
;
569 BlockDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
572 bdrv_detach_dev(*ptr
, dev
);
573 blockdev_auto_del(*ptr
);
577 static const char *print_drive(void *ptr
)
579 return bdrv_get_device_name(ptr
);
582 static void get_pointer(Object
*obj
, Visitor
*v
, Property
*prop
,
583 const char *(*print
)(void *ptr
),
584 const char *name
, Error
**errp
)
586 DeviceState
*dev
= DEVICE(obj
);
587 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
590 p
= (char *) (*ptr
? print(*ptr
) : "");
591 visit_type_str(v
, &p
, name
, errp
);
594 static void set_pointer(Object
*obj
, Visitor
*v
, Property
*prop
,
595 int (*parse
)(DeviceState
*dev
, const char *str
, void **ptr
),
596 const char *name
, Error
**errp
)
598 DeviceState
*dev
= DEVICE(obj
);
599 Error
*local_err
= NULL
;
600 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
604 if (dev
->state
!= DEV_STATE_CREATED
) {
605 error_set(errp
, QERR_PERMISSION_DENIED
);
609 visit_type_str(v
, &str
, name
, &local_err
);
611 error_propagate(errp
, local_err
);
616 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
619 ret
= parse(dev
, str
, ptr
);
620 error_set_from_qdev_prop_error(errp
, ret
, dev
, prop
, str
);
624 static void get_drive(Object
*obj
, Visitor
*v
, void *opaque
,
625 const char *name
, Error
**errp
)
627 get_pointer(obj
, v
, opaque
, print_drive
, name
, errp
);
630 static void set_drive(Object
*obj
, Visitor
*v
, void *opaque
,
631 const char *name
, Error
**errp
)
633 set_pointer(obj
, v
, opaque
, parse_drive
, name
, errp
);
636 PropertyInfo qdev_prop_drive
= {
640 .release
= release_drive
,
643 /* --- character device --- */
645 static int parse_chr(DeviceState
*dev
, const char *str
, void **ptr
)
647 CharDriverState
*chr
= qemu_chr_find(str
);
651 if (chr
->avail_connections
< 1) {
655 --chr
->avail_connections
;
659 static void release_chr(Object
*obj
, const char *name
, void *opaque
)
661 DeviceState
*dev
= DEVICE(obj
);
662 Property
*prop
= opaque
;
663 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
666 qemu_chr_add_handlers(*ptr
, NULL
, NULL
, NULL
, NULL
);
671 static const char *print_chr(void *ptr
)
673 CharDriverState
*chr
= ptr
;
675 return chr
->label
? chr
->label
: "";
678 static void get_chr(Object
*obj
, Visitor
*v
, void *opaque
,
679 const char *name
, Error
**errp
)
681 get_pointer(obj
, v
, opaque
, print_chr
, name
, errp
);
684 static void set_chr(Object
*obj
, Visitor
*v
, void *opaque
,
685 const char *name
, Error
**errp
)
687 set_pointer(obj
, v
, opaque
, parse_chr
, name
, errp
);
690 PropertyInfo qdev_prop_chr
= {
694 .release
= release_chr
,
697 /* --- netdev device --- */
699 static int parse_netdev(DeviceState
*dev
, const char *str
, void **ptr
)
701 VLANClientState
*netdev
= qemu_find_netdev(str
);
703 if (netdev
== NULL
) {
713 static const char *print_netdev(void *ptr
)
715 VLANClientState
*netdev
= ptr
;
717 return netdev
->name
? netdev
->name
: "";
720 static void get_netdev(Object
*obj
, Visitor
*v
, void *opaque
,
721 const char *name
, Error
**errp
)
723 get_pointer(obj
, v
, opaque
, print_netdev
, name
, errp
);
726 static void set_netdev(Object
*obj
, Visitor
*v
, void *opaque
,
727 const char *name
, Error
**errp
)
729 set_pointer(obj
, v
, opaque
, parse_netdev
, name
, errp
);
732 PropertyInfo qdev_prop_netdev
= {
740 static int parse_vlan(DeviceState
*dev
, Property
*prop
, const char *str
)
742 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
745 if (sscanf(str
, "%d", &id
) != 1)
747 *ptr
= qemu_find_vlan(id
, 1);
753 static int print_vlan(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
755 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
758 return snprintf(dest
, len
, "%d", (*ptr
)->id
);
760 return snprintf(dest
, len
, "<null>");
764 static void get_vlan(Object
*obj
, Visitor
*v
, void *opaque
,
765 const char *name
, Error
**errp
)
767 DeviceState
*dev
= DEVICE(obj
);
768 Property
*prop
= opaque
;
769 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
772 id
= *ptr
? (*ptr
)->id
: -1;
773 visit_type_int(v
, &id
, name
, errp
);
776 static void set_vlan(Object
*obj
, Visitor
*v
, void *opaque
,
777 const char *name
, Error
**errp
)
779 DeviceState
*dev
= DEVICE(obj
);
780 Property
*prop
= opaque
;
781 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
782 Error
*local_err
= NULL
;
786 if (dev
->state
!= DEV_STATE_CREATED
) {
787 error_set(errp
, QERR_PERMISSION_DENIED
);
791 visit_type_int(v
, &id
, name
, &local_err
);
793 error_propagate(errp
, local_err
);
800 vlan
= qemu_find_vlan(id
, 1);
802 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
,
803 name
, prop
->info
->name
);
809 PropertyInfo qdev_prop_vlan
= {
817 /* --- pointer --- */
819 /* Not a proper property, just for dirty hacks. TODO Remove it! */
820 PropertyInfo qdev_prop_ptr
= {
824 /* --- mac address --- */
827 * accepted syntax versions:
831 static void get_mac(Object
*obj
, Visitor
*v
, void *opaque
,
832 const char *name
, Error
**errp
)
834 DeviceState
*dev
= DEVICE(obj
);
835 Property
*prop
= opaque
;
836 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
837 char buffer
[2 * 6 + 5 + 1];
840 snprintf(buffer
, sizeof(buffer
), "%02x:%02x:%02x:%02x:%02x:%02x",
841 mac
->a
[0], mac
->a
[1], mac
->a
[2],
842 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
844 visit_type_str(v
, &p
, name
, errp
);
847 static void set_mac(Object
*obj
, Visitor
*v
, void *opaque
,
848 const char *name
, Error
**errp
)
850 DeviceState
*dev
= DEVICE(obj
);
851 Property
*prop
= opaque
;
852 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
853 Error
*local_err
= NULL
;
857 if (dev
->state
!= DEV_STATE_CREATED
) {
858 error_set(errp
, QERR_PERMISSION_DENIED
);
862 visit_type_str(v
, &str
, name
, &local_err
);
864 error_propagate(errp
, local_err
);
868 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
869 if (!qemu_isxdigit(str
[pos
]))
871 if (!qemu_isxdigit(str
[pos
+1]))
874 if (str
[pos
+2] != '\0')
877 if (str
[pos
+2] != ':' && str
[pos
+2] != '-')
880 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
885 error_set_from_qdev_prop_error(errp
, EINVAL
, dev
, prop
, str
);
888 PropertyInfo qdev_prop_macaddr
= {
895 /* --- lost tick policy --- */
897 static const char *lost_tick_policy_table
[LOST_TICK_MAX
+1] = {
898 [LOST_TICK_DISCARD
] = "discard",
899 [LOST_TICK_DELAY
] = "delay",
900 [LOST_TICK_MERGE
] = "merge",
901 [LOST_TICK_SLEW
] = "slew",
902 [LOST_TICK_MAX
] = NULL
,
905 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy
) != sizeof(int));
907 static void get_enum(Object
*obj
, Visitor
*v
, void *opaque
,
908 const char *name
, Error
**errp
)
910 DeviceState
*dev
= DEVICE(obj
);
911 Property
*prop
= opaque
;
912 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
914 visit_type_enum(v
, ptr
, prop
->info
->enum_table
,
915 prop
->info
->name
, prop
->name
, errp
);
918 static void set_enum(Object
*obj
, Visitor
*v
, void *opaque
,
919 const char *name
, Error
**errp
)
921 DeviceState
*dev
= DEVICE(obj
);
922 Property
*prop
= opaque
;
923 int *ptr
= qdev_get_prop_ptr(dev
, prop
);
925 if (dev
->state
!= DEV_STATE_CREATED
) {
926 error_set(errp
, QERR_PERMISSION_DENIED
);
930 visit_type_enum(v
, ptr
, prop
->info
->enum_table
,
931 prop
->info
->name
, prop
->name
, errp
);
934 PropertyInfo qdev_prop_losttickpolicy
= {
935 .name
= "LostTickPolicy",
936 .enum_table
= lost_tick_policy_table
,
941 /* --- pci address --- */
944 * bus-local address, i.e. "$slot" or "$slot.$fn"
946 static int parse_pci_devfn(DeviceState
*dev
, Property
*prop
, const char *str
)
948 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
949 unsigned int slot
, fn
, n
;
951 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
953 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
963 *ptr
= slot
<< 3 | fn
;
967 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
969 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
972 return snprintf(dest
, len
, "<unset>");
974 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
978 PropertyInfo qdev_prop_pci_devfn
= {
980 .legacy_name
= "pci-devfn",
981 .parse
= parse_pci_devfn
,
982 .print
= print_pci_devfn
,
985 /* FIXME: this should be -1...255, but the address is stored
986 * into an uint32_t rather than int32_t.
989 .max
= 0xFFFFFFFFULL
,
992 /* --- public helpers --- */
994 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
998 while (props
->name
) {
999 if (strcmp(props
->name
, name
) == 0)
1006 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
1010 /* device properties */
1011 prop
= qdev_prop_walk(qdev_get_props(dev
), name
);
1015 /* bus properties */
1016 prop
= qdev_prop_walk(dev
->parent_bus
->info
->props
, name
);
1023 int qdev_prop_exists(DeviceState
*dev
, const char *name
)
1025 return qdev_prop_find(dev
, name
) ? true : false;
1028 void error_set_from_qdev_prop_error(Error
**errp
, int ret
, DeviceState
*dev
,
1029 Property
*prop
, const char *value
)
1033 error_set(errp
, QERR_PROPERTY_VALUE_IN_USE
,
1034 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1038 error_set(errp
, QERR_PROPERTY_VALUE_BAD
,
1039 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1042 error_set(errp
, QERR_PROPERTY_VALUE_NOT_FOUND
,
1043 object_get_typename(OBJECT(dev
)), prop
->name
, value
);
1050 int qdev_prop_parse(DeviceState
*dev
, const char *name
, const char *value
)
1055 legacy_name
= g_strdup_printf("legacy-%s", name
);
1056 if (object_property_get_type(OBJECT(dev
), legacy_name
, NULL
)) {
1057 object_property_set_str(OBJECT(dev
), value
, legacy_name
, &err
);
1059 object_property_set_str(OBJECT(dev
), value
, name
, &err
);
1061 g_free(legacy_name
);
1064 qerror_report_err(err
);
1071 void qdev_prop_set_bit(DeviceState
*dev
, const char *name
, bool value
)
1074 object_property_set_bool(OBJECT(dev
), value
, name
, &errp
);
1078 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
1081 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1085 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
1088 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1092 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
1095 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1099 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
1102 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1106 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
1109 object_property_set_int(OBJECT(dev
), value
, name
, &errp
);
1113 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, char *value
)
1116 object_property_set_str(OBJECT(dev
), value
, name
, &errp
);
1120 int qdev_prop_set_drive(DeviceState
*dev
, const char *name
, BlockDriverState
*value
)
1123 object_property_set_str(OBJECT(dev
), bdrv_get_device_name(value
),
1126 qerror_report_err(errp
);
1133 void qdev_prop_set_drive_nofail(DeviceState
*dev
, const char *name
, BlockDriverState
*value
)
1135 if (qdev_prop_set_drive(dev
, name
, value
) < 0) {
1139 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
, CharDriverState
*value
)
1142 assert(value
->label
);
1143 object_property_set_str(OBJECT(dev
), value
->label
, name
, &errp
);
1147 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
, VLANClientState
*value
)
1150 assert(value
->name
);
1151 object_property_set_str(OBJECT(dev
), value
->name
, name
, &errp
);
1155 void qdev_prop_set_vlan(DeviceState
*dev
, const char *name
, VLANState
*value
)
1158 object_property_set_int(OBJECT(dev
), value
? value
->id
: -1, name
, &errp
);
1162 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
, uint8_t *value
)
1165 char str
[2 * 6 + 5 + 1];
1166 snprintf(str
, sizeof(str
), "%02x:%02x:%02x:%02x:%02x:%02x",
1167 value
[0], value
[1], value
[2], value
[3], value
[4], value
[5]);
1169 object_property_set_str(OBJECT(dev
), str
, name
, &errp
);
1173 void qdev_prop_set_enum(DeviceState
*dev
, const char *name
, int value
)
1178 prop
= qdev_prop_find(dev
, name
);
1179 object_property_set_str(OBJECT(dev
), prop
->info
->enum_table
[value
],
1184 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
1189 prop
= qdev_prop_find(dev
, name
);
1190 assert(prop
&& prop
->info
== &qdev_prop_ptr
);
1191 ptr
= qdev_get_prop_ptr(dev
, prop
);
1195 void qdev_prop_set_defaults(DeviceState
*dev
, Property
*props
)
1197 Object
*obj
= OBJECT(dev
);
1200 for (; props
->name
; props
++) {
1202 if (props
->qtype
== QTYPE_NONE
) {
1205 if (props
->qtype
== QTYPE_QBOOL
) {
1206 object_property_set_bool(obj
, props
->defval
, props
->name
, &errp
);
1207 } else if (props
->info
->enum_table
) {
1208 object_property_set_str(obj
, props
->info
->enum_table
[props
->defval
],
1209 props
->name
, &errp
);
1210 } else if (props
->qtype
== QTYPE_QINT
) {
1211 object_property_set_int(obj
, props
->defval
, props
->name
, &errp
);
1217 static QTAILQ_HEAD(, GlobalProperty
) global_props
= QTAILQ_HEAD_INITIALIZER(global_props
);
1219 static void qdev_prop_register_global(GlobalProperty
*prop
)
1221 QTAILQ_INSERT_TAIL(&global_props
, prop
, next
);
1224 void qdev_prop_register_global_list(GlobalProperty
*props
)
1228 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
1229 qdev_prop_register_global(props
+i
);
1233 void qdev_prop_set_globals(DeviceState
*dev
)
1235 GlobalProperty
*prop
;
1237 QTAILQ_FOREACH(prop
, &global_props
, next
) {
1238 if (strcmp(object_get_typename(OBJECT(dev
)), prop
->driver
) != 0 &&
1239 strcmp(qdev_get_bus_info(dev
)->name
, prop
->driver
) != 0) {
1242 if (qdev_prop_parse(dev
, prop
->property
, prop
->value
) != 0) {
1248 static int qdev_add_one_global(QemuOpts
*opts
, void *opaque
)
1252 g
= g_malloc0(sizeof(*g
));
1253 g
->driver
= qemu_opt_get(opts
, "driver");
1254 g
->property
= qemu_opt_get(opts
, "property");
1255 g
->value
= qemu_opt_get(opts
, "value");
1256 qdev_prop_register_global(g
);
1260 void qemu_add_globals(void)
1262 qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global
, NULL
, 0);