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 int print_drive(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
318 DriveInfo
**ptr
= qdev_get_prop_ptr(dev
, prop
);
319 return snprintf(dest
, len
, "%s", (*ptr
) ? (*ptr
)->id
: "<null>");
322 PropertyInfo qdev_prop_drive
= {
324 .type
= PROP_TYPE_DRIVE
,
325 .size
= sizeof(DriveInfo
*),
326 .parse
= parse_drive
,
327 .print
= print_drive
,
330 /* --- character device --- */
332 static int parse_chr(DeviceState
*dev
, Property
*prop
, const char *str
)
334 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
336 *ptr
= qemu_chr_find(str
);
342 static int print_chr(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
344 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
346 if (*ptr
&& (*ptr
)->label
) {
347 return snprintf(dest
, len
, "%s", (*ptr
)->label
);
349 return snprintf(dest
, len
, "<null>");
353 PropertyInfo qdev_prop_chr
= {
355 .type
= PROP_TYPE_CHR
,
356 .size
= sizeof(CharDriverState
*),
361 /* --- netdev device --- */
363 static int parse_netdev(DeviceState
*dev
, Property
*prop
, const char *str
)
365 VLANClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
367 *ptr
= qemu_find_netdev(str
);
376 static int print_netdev(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
378 VLANClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
380 if (*ptr
&& (*ptr
)->name
) {
381 return snprintf(dest
, len
, "%s", (*ptr
)->name
);
383 return snprintf(dest
, len
, "<null>");
387 PropertyInfo qdev_prop_netdev
= {
389 .type
= PROP_TYPE_NETDEV
,
390 .size
= sizeof(VLANClientState
*),
391 .parse
= parse_netdev
,
392 .print
= print_netdev
,
397 static int parse_vlan(DeviceState
*dev
, Property
*prop
, const char *str
)
399 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
402 if (sscanf(str
, "%d", &id
) != 1)
404 *ptr
= qemu_find_vlan(id
, 1);
410 static int print_vlan(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
412 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
415 return snprintf(dest
, len
, "%d", (*ptr
)->id
);
417 return snprintf(dest
, len
, "<null>");
421 PropertyInfo qdev_prop_vlan
= {
423 .type
= PROP_TYPE_VLAN
,
424 .size
= sizeof(VLANClientState
*),
429 /* --- pointer --- */
431 /* Not a proper property, just for dirty hacks. TODO Remove it! */
432 PropertyInfo qdev_prop_ptr
= {
434 .type
= PROP_TYPE_PTR
,
435 .size
= sizeof(void*),
438 /* --- mac address --- */
441 * accepted syntax versions:
445 static int parse_mac(DeviceState
*dev
, Property
*prop
, const char *str
)
447 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
451 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
452 if (!qemu_isxdigit(str
[pos
]))
454 if (!qemu_isxdigit(str
[pos
+1]))
457 if (str
[pos
+2] != '\0')
460 if (str
[pos
+2] != ':' && str
[pos
+2] != '-')
463 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
468 static int print_mac(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
470 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
472 return snprintf(dest
, len
, "%02x:%02x:%02x:%02x:%02x:%02x",
473 mac
->a
[0], mac
->a
[1], mac
->a
[2],
474 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
477 PropertyInfo qdev_prop_macaddr
= {
479 .type
= PROP_TYPE_MACADDR
,
480 .size
= sizeof(MACAddr
),
485 /* --- pci address --- */
488 * bus-local address, i.e. "$slot" or "$slot.$fn"
490 static int parse_pci_devfn(DeviceState
*dev
, Property
*prop
, const char *str
)
492 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
493 unsigned int slot
, fn
, n
;
495 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
497 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
505 *ptr
= slot
<< 3 | fn
;
509 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
511 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
514 return snprintf(dest
, len
, "<unset>");
516 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
520 PropertyInfo qdev_prop_pci_devfn
= {
522 .type
= PROP_TYPE_UINT32
,
523 .size
= sizeof(uint32_t),
524 .parse
= parse_pci_devfn
,
525 .print
= print_pci_devfn
,
528 /* --- public helpers --- */
530 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
534 while (props
->name
) {
535 if (strcmp(props
->name
, name
) == 0)
542 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
546 /* device properties */
547 prop
= qdev_prop_walk(dev
->info
->props
, name
);
552 prop
= qdev_prop_walk(dev
->parent_bus
->info
->props
, name
);
559 int qdev_prop_exists(DeviceState
*dev
, const char *name
)
561 return qdev_prop_find(dev
, name
) ? true : false;
564 int qdev_prop_parse(DeviceState
*dev
, const char *name
, const char *value
)
569 prop
= qdev_prop_find(dev
, name
);
571 * TODO Properties without a parse method are just for dirty
572 * hacks. qdev_prop_ptr is the only such PropertyInfo. It's
573 * marked for removal. The test !prop->info->parse should be
574 * removed along with it.
576 if (!prop
|| !prop
->info
->parse
) {
577 qerror_report(QERR_PROPERTY_NOT_FOUND
, dev
->info
->name
, name
);
580 ret
= prop
->info
->parse(dev
, prop
, value
);
584 qerror_report(QERR_PROPERTY_VALUE_IN_USE
,
585 dev
->info
->name
, name
, value
);
589 qerror_report(QERR_PROPERTY_VALUE_BAD
,
590 dev
->info
->name
, name
, value
);
593 qerror_report(QERR_PROPERTY_VALUE_NOT_FOUND
,
594 dev
->info
->name
, name
, value
);
602 void qdev_prop_set(DeviceState
*dev
, const char *name
, void *src
, enum PropertyType type
)
606 prop
= qdev_prop_find(dev
, name
);
608 fprintf(stderr
, "%s: property \"%s.%s\" not found\n",
609 __FUNCTION__
, dev
->info
->name
, name
);
612 if (prop
->info
->type
!= type
) {
613 fprintf(stderr
, "%s: property \"%s.%s\" type mismatch\n",
614 __FUNCTION__
, dev
->info
->name
, name
);
617 qdev_prop_cpy(dev
, prop
, src
);
620 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
622 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT8
);
625 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
627 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT16
);
630 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
632 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT32
);
635 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
637 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_INT32
);
640 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
642 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT64
);
645 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, char *value
)
647 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_STRING
);
650 void qdev_prop_set_drive(DeviceState
*dev
, const char *name
, DriveInfo
*value
)
652 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_DRIVE
);
655 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
, CharDriverState
*value
)
657 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_CHR
);
660 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
, VLANClientState
*value
)
662 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_NETDEV
);
665 void qdev_prop_set_vlan(DeviceState
*dev
, const char *name
, VLANState
*value
)
667 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_VLAN
);
670 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
, uint8_t *value
)
672 qdev_prop_set(dev
, name
, value
, PROP_TYPE_MACADDR
);
675 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
677 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_PTR
);
680 void qdev_prop_set_defaults(DeviceState
*dev
, Property
*props
)
684 while (props
->name
) {
686 qdev_prop_cpy(dev
, props
, props
->defval
);
692 static QTAILQ_HEAD(, GlobalProperty
) global_props
= QTAILQ_HEAD_INITIALIZER(global_props
);
694 static void qdev_prop_register_global(GlobalProperty
*prop
)
696 QTAILQ_INSERT_TAIL(&global_props
, prop
, next
);
699 void qdev_prop_register_global_list(GlobalProperty
*props
)
703 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
704 qdev_prop_register_global(props
+i
);
708 void qdev_prop_set_globals(DeviceState
*dev
)
710 GlobalProperty
*prop
;
712 QTAILQ_FOREACH(prop
, &global_props
, next
) {
713 if (strcmp(dev
->info
->name
, prop
->driver
) != 0 &&
714 strcmp(dev
->info
->bus_info
->name
, prop
->driver
) != 0) {
717 if (qdev_prop_parse(dev
, prop
->property
, prop
->value
) != 0) {
723 static int qdev_add_one_global(QemuOpts
*opts
, void *opaque
)
727 g
= qemu_mallocz(sizeof(*g
));
728 g
->driver
= qemu_opt_get(opts
, "driver");
729 g
->property
= qemu_opt_get(opts
, "property");
730 g
->value
= qemu_opt_get(opts
, "value");
731 qdev_prop_register_global(g
);
735 void qemu_add_globals(void)
737 qemu_opts_foreach(&qemu_global_opts
, qdev_add_one_global
, NULL
, 0);