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 DriveInfo
**ptr
= qdev_get_prop_ptr(dev
, prop
);
310 *ptr
= drive_get_by_id(str
);
316 static void free_drive(DeviceState
*dev
, Property
*prop
)
318 DriveInfo
**ptr
= qdev_get_prop_ptr(dev
, prop
);
321 blockdev_auto_del((*ptr
)->bdrv
);
325 static int print_drive(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
327 DriveInfo
**ptr
= qdev_get_prop_ptr(dev
, prop
);
328 return snprintf(dest
, len
, "%s", (*ptr
) ? (*ptr
)->id
: "<null>");
331 PropertyInfo qdev_prop_drive
= {
333 .type
= PROP_TYPE_DRIVE
,
334 .size
= sizeof(DriveInfo
*),
335 .parse
= parse_drive
,
336 .print
= print_drive
,
340 /* --- character device --- */
342 static int parse_chr(DeviceState
*dev
, Property
*prop
, const char *str
)
344 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
346 *ptr
= qemu_chr_find(str
);
352 static int print_chr(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
354 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
356 if (*ptr
&& (*ptr
)->label
) {
357 return snprintf(dest
, len
, "%s", (*ptr
)->label
);
359 return snprintf(dest
, len
, "<null>");
363 PropertyInfo qdev_prop_chr
= {
365 .type
= PROP_TYPE_CHR
,
366 .size
= sizeof(CharDriverState
*),
371 /* --- netdev device --- */
373 static int parse_netdev(DeviceState
*dev
, Property
*prop
, const char *str
)
375 VLANClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
377 *ptr
= qemu_find_netdev(str
);
386 static int print_netdev(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
388 VLANClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
390 if (*ptr
&& (*ptr
)->name
) {
391 return snprintf(dest
, len
, "%s", (*ptr
)->name
);
393 return snprintf(dest
, len
, "<null>");
397 PropertyInfo qdev_prop_netdev
= {
399 .type
= PROP_TYPE_NETDEV
,
400 .size
= sizeof(VLANClientState
*),
401 .parse
= parse_netdev
,
402 .print
= print_netdev
,
407 static int parse_vlan(DeviceState
*dev
, Property
*prop
, const char *str
)
409 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
412 if (sscanf(str
, "%d", &id
) != 1)
414 *ptr
= qemu_find_vlan(id
, 1);
420 static int print_vlan(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
422 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
425 return snprintf(dest
, len
, "%d", (*ptr
)->id
);
427 return snprintf(dest
, len
, "<null>");
431 PropertyInfo qdev_prop_vlan
= {
433 .type
= PROP_TYPE_VLAN
,
434 .size
= sizeof(VLANClientState
*),
439 /* --- pointer --- */
441 /* Not a proper property, just for dirty hacks. TODO Remove it! */
442 PropertyInfo qdev_prop_ptr
= {
444 .type
= PROP_TYPE_PTR
,
445 .size
= sizeof(void*),
448 /* --- mac address --- */
451 * accepted syntax versions:
455 static int parse_mac(DeviceState
*dev
, Property
*prop
, const char *str
)
457 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
461 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
462 if (!qemu_isxdigit(str
[pos
]))
464 if (!qemu_isxdigit(str
[pos
+1]))
467 if (str
[pos
+2] != '\0')
470 if (str
[pos
+2] != ':' && str
[pos
+2] != '-')
473 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
478 static int print_mac(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
480 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
482 return snprintf(dest
, len
, "%02x:%02x:%02x:%02x:%02x:%02x",
483 mac
->a
[0], mac
->a
[1], mac
->a
[2],
484 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
487 PropertyInfo qdev_prop_macaddr
= {
489 .type
= PROP_TYPE_MACADDR
,
490 .size
= sizeof(MACAddr
),
495 /* --- pci address --- */
498 * bus-local address, i.e. "$slot" or "$slot.$fn"
500 static int parse_pci_devfn(DeviceState
*dev
, Property
*prop
, const char *str
)
502 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
503 unsigned int slot
, fn
, n
;
505 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
507 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
515 *ptr
= slot
<< 3 | fn
;
519 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
521 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
524 return snprintf(dest
, len
, "<unset>");
526 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
530 PropertyInfo qdev_prop_pci_devfn
= {
532 .type
= PROP_TYPE_UINT32
,
533 .size
= sizeof(uint32_t),
534 .parse
= parse_pci_devfn
,
535 .print
= print_pci_devfn
,
538 /* --- public helpers --- */
540 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
544 while (props
->name
) {
545 if (strcmp(props
->name
, name
) == 0)
552 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
556 /* device properties */
557 prop
= qdev_prop_walk(dev
->info
->props
, name
);
562 prop
= qdev_prop_walk(dev
->parent_bus
->info
->props
, name
);
569 int qdev_prop_exists(DeviceState
*dev
, const char *name
)
571 return qdev_prop_find(dev
, name
) ? true : false;
574 int qdev_prop_parse(DeviceState
*dev
, const char *name
, const char *value
)
579 prop
= qdev_prop_find(dev
, name
);
581 * TODO Properties without a parse method are just for dirty
582 * hacks. qdev_prop_ptr is the only such PropertyInfo. It's
583 * marked for removal. The test !prop->info->parse should be
584 * removed along with it.
586 if (!prop
|| !prop
->info
->parse
) {
587 qerror_report(QERR_PROPERTY_NOT_FOUND
, dev
->info
->name
, name
);
590 ret
= prop
->info
->parse(dev
, prop
, value
);
594 qerror_report(QERR_PROPERTY_VALUE_IN_USE
,
595 dev
->info
->name
, name
, value
);
599 qerror_report(QERR_PROPERTY_VALUE_BAD
,
600 dev
->info
->name
, name
, value
);
603 qerror_report(QERR_PROPERTY_VALUE_NOT_FOUND
,
604 dev
->info
->name
, name
, value
);
612 void qdev_prop_set(DeviceState
*dev
, const char *name
, void *src
, enum PropertyType type
)
616 prop
= qdev_prop_find(dev
, name
);
618 fprintf(stderr
, "%s: property \"%s.%s\" not found\n",
619 __FUNCTION__
, dev
->info
->name
, name
);
622 if (prop
->info
->type
!= type
) {
623 fprintf(stderr
, "%s: property \"%s.%s\" type mismatch\n",
624 __FUNCTION__
, dev
->info
->name
, name
);
627 qdev_prop_cpy(dev
, prop
, src
);
630 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
632 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT8
);
635 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
637 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT16
);
640 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
642 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT32
);
645 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
647 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_INT32
);
650 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
652 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT64
);
655 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, char *value
)
657 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_STRING
);
660 void qdev_prop_set_drive(DeviceState
*dev
, const char *name
, DriveInfo
*value
)
662 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_DRIVE
);
665 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
, CharDriverState
*value
)
667 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_CHR
);
670 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
, VLANClientState
*value
)
672 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_NETDEV
);
675 void qdev_prop_set_vlan(DeviceState
*dev
, const char *name
, VLANState
*value
)
677 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_VLAN
);
680 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
, uint8_t *value
)
682 qdev_prop_set(dev
, name
, value
, PROP_TYPE_MACADDR
);
685 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
687 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_PTR
);
690 void qdev_prop_set_defaults(DeviceState
*dev
, Property
*props
)
694 while (props
->name
) {
696 qdev_prop_cpy(dev
, props
, props
->defval
);
702 static QTAILQ_HEAD(, GlobalProperty
) global_props
= QTAILQ_HEAD_INITIALIZER(global_props
);
704 static void qdev_prop_register_global(GlobalProperty
*prop
)
706 QTAILQ_INSERT_TAIL(&global_props
, prop
, next
);
709 void qdev_prop_register_global_list(GlobalProperty
*props
)
713 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
714 qdev_prop_register_global(props
+i
);
718 void qdev_prop_set_globals(DeviceState
*dev
)
720 GlobalProperty
*prop
;
722 QTAILQ_FOREACH(prop
, &global_props
, next
) {
723 if (strcmp(dev
->info
->name
, prop
->driver
) != 0 &&
724 strcmp(dev
->info
->bus_info
->name
, prop
->driver
) != 0) {
727 if (qdev_prop_parse(dev
, prop
->property
, prop
->value
) != 0) {
733 static int qdev_add_one_global(QemuOpts
*opts
, void *opaque
)
737 g
= qemu_mallocz(sizeof(*g
));
738 g
->driver
= qemu_opt_get(opts
, "driver");
739 g
->property
= qemu_opt_get(opts
, "property");
740 g
->value
= qemu_opt_get(opts
, "value");
741 qdev_prop_register_global(g
);
745 void qemu_add_globals(void)
747 qemu_opts_foreach(&qemu_global_opts
, qdev_add_one_global
, NULL
, 0);