5 void *qdev_get_prop_ptr(DeviceState
*dev
, Property
*prop
)
12 static uint32_t qdev_get_prop_mask(Property
*prop
)
14 assert(prop
->info
->type
== PROP_TYPE_BIT
);
15 return 0x1 << prop
->bitnr
;
18 static void bit_prop_set(DeviceState
*dev
, Property
*props
, bool val
)
20 uint32_t *p
= qdev_get_prop_ptr(dev
, props
);
21 uint32_t mask
= qdev_get_prop_mask(props
);
28 static void qdev_prop_cpy(DeviceState
*dev
, Property
*props
, void *src
)
30 if (props
->info
->type
== PROP_TYPE_BIT
) {
32 bit_prop_set(dev
, props
, *defval
);
34 char *dst
= qdev_get_prop_ptr(dev
, props
);
35 memcpy(dst
, src
, props
->info
->size
);
40 static int parse_bit(DeviceState
*dev
, Property
*prop
, const char *str
)
42 if (!strncasecmp(str
, "on", 2))
43 bit_prop_set(dev
, prop
, true);
44 else if (!strncasecmp(str
, "off", 3))
45 bit_prop_set(dev
, prop
, false);
51 static int print_bit(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
53 uint8_t *p
= qdev_get_prop_ptr(dev
, prop
);
54 return snprintf(dest
, len
, (*p
& qdev_get_prop_mask(prop
)) ? "on" : "off");
57 PropertyInfo qdev_prop_bit
= {
59 .type
= PROP_TYPE_BIT
,
60 .size
= sizeof(uint32_t),
65 /* --- 8bit integer --- */
67 static int parse_uint8(DeviceState
*dev
, Property
*prop
, const char *str
)
69 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
72 /* accept both hex and decimal */
73 *ptr
= strtoul(str
, &end
, 0);
74 if ((*end
!= '\0') || (end
== str
)) {
81 static int print_uint8(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
83 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
84 return snprintf(dest
, len
, "%" PRIu8
, *ptr
);
87 PropertyInfo qdev_prop_uint8
= {
89 .type
= PROP_TYPE_UINT8
,
90 .size
= sizeof(uint8_t),
95 /* --- 16bit integer --- */
97 static int parse_uint16(DeviceState
*dev
, Property
*prop
, const char *str
)
99 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
102 /* accept both hex and decimal */
103 *ptr
= strtoul(str
, &end
, 0);
104 if ((*end
!= '\0') || (end
== str
)) {
111 static int print_uint16(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
113 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
114 return snprintf(dest
, len
, "%" PRIu16
, *ptr
);
117 PropertyInfo qdev_prop_uint16
= {
119 .type
= PROP_TYPE_UINT16
,
120 .size
= sizeof(uint16_t),
121 .parse
= parse_uint16
,
122 .print
= print_uint16
,
125 /* --- 32bit integer --- */
127 static int parse_uint32(DeviceState
*dev
, Property
*prop
, const char *str
)
129 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
132 /* accept both hex and decimal */
133 *ptr
= strtoul(str
, &end
, 0);
134 if ((*end
!= '\0') || (end
== str
)) {
141 static int print_uint32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
143 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
144 return snprintf(dest
, len
, "%" PRIu32
, *ptr
);
147 PropertyInfo qdev_prop_uint32
= {
149 .type
= PROP_TYPE_UINT32
,
150 .size
= sizeof(uint32_t),
151 .parse
= parse_uint32
,
152 .print
= print_uint32
,
155 static int parse_int32(DeviceState
*dev
, Property
*prop
, const char *str
)
157 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
160 *ptr
= strtol(str
, &end
, 10);
161 if ((*end
!= '\0') || (end
== str
)) {
168 static int print_int32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
170 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
171 return snprintf(dest
, len
, "%" PRId32
, *ptr
);
174 PropertyInfo qdev_prop_int32
= {
176 .type
= PROP_TYPE_INT32
,
177 .size
= sizeof(int32_t),
178 .parse
= parse_int32
,
179 .print
= print_int32
,
182 /* --- 32bit hex value --- */
184 static int parse_hex32(DeviceState
*dev
, Property
*prop
, const char *str
)
186 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
189 *ptr
= strtoul(str
, &end
, 16);
190 if ((*end
!= '\0') || (end
== str
)) {
197 static int print_hex32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
199 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
200 return snprintf(dest
, len
, "0x%" PRIx32
, *ptr
);
203 PropertyInfo qdev_prop_hex32
= {
205 .type
= PROP_TYPE_UINT32
,
206 .size
= sizeof(uint32_t),
207 .parse
= parse_hex32
,
208 .print
= print_hex32
,
211 /* --- 64bit integer --- */
213 static int parse_uint64(DeviceState
*dev
, Property
*prop
, const char *str
)
215 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
218 /* accept both hex and decimal */
219 *ptr
= strtoull(str
, &end
, 0);
220 if ((*end
!= '\0') || (end
== str
)) {
227 static int print_uint64(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
229 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
230 return snprintf(dest
, len
, "%" PRIu64
, *ptr
);
233 PropertyInfo qdev_prop_uint64
= {
235 .type
= PROP_TYPE_UINT64
,
236 .size
= sizeof(uint64_t),
237 .parse
= parse_uint64
,
238 .print
= print_uint64
,
241 /* --- 64bit hex value --- */
243 static int parse_hex64(DeviceState
*dev
, Property
*prop
, const char *str
)
245 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
248 *ptr
= strtoull(str
, &end
, 16);
249 if ((*end
!= '\0') || (end
== str
)) {
256 static int print_hex64(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
258 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
259 return snprintf(dest
, len
, "0x%" PRIx64
, *ptr
);
262 PropertyInfo qdev_prop_hex64
= {
264 .type
= PROP_TYPE_UINT64
,
265 .size
= sizeof(uint64_t),
266 .parse
= parse_hex64
,
267 .print
= print_hex64
,
272 static int parse_string(DeviceState
*dev
, Property
*prop
, const char *str
)
274 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
278 *ptr
= qemu_strdup(str
);
282 static void free_string(DeviceState
*dev
, Property
*prop
)
284 qemu_free(*(char **)qdev_get_prop_ptr(dev
, prop
));
287 static int print_string(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
289 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
291 return snprintf(dest
, len
, "<null>");
292 return snprintf(dest
, len
, "\"%s\"", *ptr
);
295 PropertyInfo qdev_prop_string
= {
297 .type
= PROP_TYPE_STRING
,
298 .size
= sizeof(char*),
299 .parse
= parse_string
,
300 .print
= print_string
,
306 static int parse_drive(DeviceState
*dev
, Property
*prop
, const char *str
)
308 BlockDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
309 BlockDriverState
*bs
;
318 static void free_drive(DeviceState
*dev
, Property
*prop
)
320 BlockDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
323 blockdev_auto_del(*ptr
);
327 static int print_drive(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
329 BlockDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
330 return snprintf(dest
, len
, "%s",
331 *ptr
? bdrv_get_device_name(*ptr
) : "<null>");
334 PropertyInfo qdev_prop_drive
= {
336 .type
= PROP_TYPE_DRIVE
,
337 .size
= sizeof(BlockDriverState
*),
338 .parse
= parse_drive
,
339 .print
= print_drive
,
343 /* --- character device --- */
345 static int parse_chr(DeviceState
*dev
, Property
*prop
, const char *str
)
347 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
349 *ptr
= qemu_chr_find(str
);
355 static int print_chr(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
357 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
359 if (*ptr
&& (*ptr
)->label
) {
360 return snprintf(dest
, len
, "%s", (*ptr
)->label
);
362 return snprintf(dest
, len
, "<null>");
366 PropertyInfo qdev_prop_chr
= {
368 .type
= PROP_TYPE_CHR
,
369 .size
= sizeof(CharDriverState
*),
374 /* --- netdev device --- */
376 static int parse_netdev(DeviceState
*dev
, Property
*prop
, const char *str
)
378 VLANClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
380 *ptr
= qemu_find_netdev(str
);
389 static int print_netdev(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
391 VLANClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
393 if (*ptr
&& (*ptr
)->name
) {
394 return snprintf(dest
, len
, "%s", (*ptr
)->name
);
396 return snprintf(dest
, len
, "<null>");
400 PropertyInfo qdev_prop_netdev
= {
402 .type
= PROP_TYPE_NETDEV
,
403 .size
= sizeof(VLANClientState
*),
404 .parse
= parse_netdev
,
405 .print
= print_netdev
,
410 static int parse_vlan(DeviceState
*dev
, Property
*prop
, const char *str
)
412 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
415 if (sscanf(str
, "%d", &id
) != 1)
417 *ptr
= qemu_find_vlan(id
, 1);
423 static int print_vlan(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
425 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
428 return snprintf(dest
, len
, "%d", (*ptr
)->id
);
430 return snprintf(dest
, len
, "<null>");
434 PropertyInfo qdev_prop_vlan
= {
436 .type
= PROP_TYPE_VLAN
,
437 .size
= sizeof(VLANClientState
*),
442 /* --- pointer --- */
444 /* Not a proper property, just for dirty hacks. TODO Remove it! */
445 PropertyInfo qdev_prop_ptr
= {
447 .type
= PROP_TYPE_PTR
,
448 .size
= sizeof(void*),
451 /* --- mac address --- */
454 * accepted syntax versions:
458 static int parse_mac(DeviceState
*dev
, Property
*prop
, const char *str
)
460 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
464 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
465 if (!qemu_isxdigit(str
[pos
]))
467 if (!qemu_isxdigit(str
[pos
+1]))
470 if (str
[pos
+2] != '\0')
473 if (str
[pos
+2] != ':' && str
[pos
+2] != '-')
476 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
481 static int print_mac(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
483 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
485 return snprintf(dest
, len
, "%02x:%02x:%02x:%02x:%02x:%02x",
486 mac
->a
[0], mac
->a
[1], mac
->a
[2],
487 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
490 PropertyInfo qdev_prop_macaddr
= {
492 .type
= PROP_TYPE_MACADDR
,
493 .size
= sizeof(MACAddr
),
498 /* --- pci address --- */
501 * bus-local address, i.e. "$slot" or "$slot.$fn"
503 static int parse_pci_devfn(DeviceState
*dev
, Property
*prop
, const char *str
)
505 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
506 unsigned int slot
, fn
, n
;
508 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
510 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
518 *ptr
= slot
<< 3 | fn
;
522 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
524 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
527 return snprintf(dest
, len
, "<unset>");
529 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
533 PropertyInfo qdev_prop_pci_devfn
= {
535 .type
= PROP_TYPE_UINT32
,
536 .size
= sizeof(uint32_t),
537 .parse
= parse_pci_devfn
,
538 .print
= print_pci_devfn
,
541 /* --- public helpers --- */
543 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
547 while (props
->name
) {
548 if (strcmp(props
->name
, name
) == 0)
555 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
559 /* device properties */
560 prop
= qdev_prop_walk(dev
->info
->props
, name
);
565 prop
= qdev_prop_walk(dev
->parent_bus
->info
->props
, name
);
572 int qdev_prop_exists(DeviceState
*dev
, const char *name
)
574 return qdev_prop_find(dev
, name
) ? true : false;
577 int qdev_prop_parse(DeviceState
*dev
, const char *name
, const char *value
)
582 prop
= qdev_prop_find(dev
, name
);
584 * TODO Properties without a parse method are just for dirty
585 * hacks. qdev_prop_ptr is the only such PropertyInfo. It's
586 * marked for removal. The test !prop->info->parse should be
587 * removed along with it.
589 if (!prop
|| !prop
->info
->parse
) {
590 qerror_report(QERR_PROPERTY_NOT_FOUND
, dev
->info
->name
, name
);
593 ret
= prop
->info
->parse(dev
, prop
, value
);
597 qerror_report(QERR_PROPERTY_VALUE_IN_USE
,
598 dev
->info
->name
, name
, value
);
602 qerror_report(QERR_PROPERTY_VALUE_BAD
,
603 dev
->info
->name
, name
, value
);
606 qerror_report(QERR_PROPERTY_VALUE_NOT_FOUND
,
607 dev
->info
->name
, name
, value
);
615 void qdev_prop_set(DeviceState
*dev
, const char *name
, void *src
, enum PropertyType type
)
619 prop
= qdev_prop_find(dev
, name
);
621 fprintf(stderr
, "%s: property \"%s.%s\" not found\n",
622 __FUNCTION__
, dev
->info
->name
, name
);
625 if (prop
->info
->type
!= type
) {
626 fprintf(stderr
, "%s: property \"%s.%s\" type mismatch\n",
627 __FUNCTION__
, dev
->info
->name
, name
);
630 qdev_prop_cpy(dev
, prop
, src
);
633 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
635 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT8
);
638 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
640 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT16
);
643 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
645 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT32
);
648 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
650 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_INT32
);
653 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
655 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT64
);
658 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, char *value
)
660 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_STRING
);
663 void qdev_prop_set_drive(DeviceState
*dev
, const char *name
, BlockDriverState
*value
)
665 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_DRIVE
);
668 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
, CharDriverState
*value
)
670 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_CHR
);
673 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
, VLANClientState
*value
)
675 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_NETDEV
);
678 void qdev_prop_set_vlan(DeviceState
*dev
, const char *name
, VLANState
*value
)
680 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_VLAN
);
683 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
, uint8_t *value
)
685 qdev_prop_set(dev
, name
, value
, PROP_TYPE_MACADDR
);
688 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
690 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_PTR
);
693 void qdev_prop_set_defaults(DeviceState
*dev
, Property
*props
)
697 while (props
->name
) {
699 qdev_prop_cpy(dev
, props
, props
->defval
);
705 static QTAILQ_HEAD(, GlobalProperty
) global_props
= QTAILQ_HEAD_INITIALIZER(global_props
);
707 static void qdev_prop_register_global(GlobalProperty
*prop
)
709 QTAILQ_INSERT_TAIL(&global_props
, prop
, next
);
712 void qdev_prop_register_global_list(GlobalProperty
*props
)
716 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
717 qdev_prop_register_global(props
+i
);
721 void qdev_prop_set_globals(DeviceState
*dev
)
723 GlobalProperty
*prop
;
725 QTAILQ_FOREACH(prop
, &global_props
, next
) {
726 if (strcmp(dev
->info
->name
, prop
->driver
) != 0 &&
727 strcmp(dev
->info
->bus_info
->name
, prop
->driver
) != 0) {
730 if (qdev_prop_parse(dev
, prop
->property
, prop
->value
) != 0) {
736 static int qdev_add_one_global(QemuOpts
*opts
, void *opaque
)
740 g
= qemu_mallocz(sizeof(*g
));
741 g
->driver
= qemu_opt_get(opts
, "driver");
742 g
->property
= qemu_opt_get(opts
, "property");
743 g
->value
= qemu_opt_get(opts
, "value");
744 qdev_prop_register_global(g
);
748 void qemu_add_globals(void)
750 qemu_opts_foreach(&qemu_global_opts
, qdev_add_one_global
, NULL
, 0);