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 fmt
= strncasecmp(str
, "0x",2) == 0 ? "%" PRIx8
: "%" PRIu8
;
74 if (sscanf(str
, fmt
, ptr
) != 1)
79 static int print_uint8(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
81 uint8_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
82 return snprintf(dest
, len
, "%" PRIu8
, *ptr
);
85 PropertyInfo qdev_prop_uint8
= {
87 .type
= PROP_TYPE_UINT8
,
88 .size
= sizeof(uint8_t),
93 /* --- 16bit integer --- */
95 static int parse_uint16(DeviceState
*dev
, Property
*prop
, const char *str
)
97 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
100 /* accept both hex and decimal */
101 fmt
= strncasecmp(str
, "0x",2) == 0 ? "%" PRIx16
: "%" PRIu16
;
102 if (sscanf(str
, fmt
, ptr
) != 1)
107 static int print_uint16(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
109 uint16_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
110 return snprintf(dest
, len
, "%" PRIu16
, *ptr
);
113 PropertyInfo qdev_prop_uint16
= {
115 .type
= PROP_TYPE_UINT16
,
116 .size
= sizeof(uint16_t),
117 .parse
= parse_uint16
,
118 .print
= print_uint16
,
121 /* --- 32bit integer --- */
123 static int parse_uint32(DeviceState
*dev
, Property
*prop
, const char *str
)
125 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
128 /* accept both hex and decimal */
129 fmt
= strncasecmp(str
, "0x",2) == 0 ? "%" PRIx32
: "%" PRIu32
;
130 if (sscanf(str
, fmt
, ptr
) != 1)
135 static int print_uint32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
137 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
138 return snprintf(dest
, len
, "%" PRIu32
, *ptr
);
141 PropertyInfo qdev_prop_uint32
= {
143 .type
= PROP_TYPE_UINT32
,
144 .size
= sizeof(uint32_t),
145 .parse
= parse_uint32
,
146 .print
= print_uint32
,
149 static int parse_int32(DeviceState
*dev
, Property
*prop
, const char *str
)
151 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
153 if (sscanf(str
, "%" PRId32
, ptr
) != 1)
158 static int print_int32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
160 int32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
161 return snprintf(dest
, len
, "%" PRId32
, *ptr
);
164 PropertyInfo qdev_prop_int32
= {
166 .type
= PROP_TYPE_INT32
,
167 .size
= sizeof(int32_t),
168 .parse
= parse_int32
,
169 .print
= print_int32
,
172 /* --- 32bit hex value --- */
174 static int parse_hex32(DeviceState
*dev
, Property
*prop
, const char *str
)
176 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
178 if (sscanf(str
, "%" PRIx32
, ptr
) != 1)
183 static int print_hex32(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
185 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
186 return snprintf(dest
, len
, "0x%" PRIx32
, *ptr
);
189 PropertyInfo qdev_prop_hex32
= {
191 .type
= PROP_TYPE_UINT32
,
192 .size
= sizeof(uint32_t),
193 .parse
= parse_hex32
,
194 .print
= print_hex32
,
197 /* --- 64bit integer --- */
199 static int parse_uint64(DeviceState
*dev
, Property
*prop
, const char *str
)
201 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
204 /* accept both hex and decimal */
205 fmt
= strncasecmp(str
, "0x",2) == 0 ? "%" PRIx64
: "%" PRIu64
;
206 if (sscanf(str
, fmt
, ptr
) != 1)
211 static int print_uint64(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
213 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
214 return snprintf(dest
, len
, "%" PRIu64
, *ptr
);
217 PropertyInfo qdev_prop_uint64
= {
219 .type
= PROP_TYPE_UINT64
,
220 .size
= sizeof(uint64_t),
221 .parse
= parse_uint64
,
222 .print
= print_uint64
,
225 /* --- 64bit hex value --- */
227 static int parse_hex64(DeviceState
*dev
, Property
*prop
, const char *str
)
229 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
231 if (sscanf(str
, "%" PRIx64
, ptr
) != 1)
236 static int print_hex64(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
238 uint64_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
239 return snprintf(dest
, len
, "0x%" PRIx64
, *ptr
);
242 PropertyInfo qdev_prop_hex64
= {
244 .type
= PROP_TYPE_UINT64
,
245 .size
= sizeof(uint64_t),
246 .parse
= parse_hex64
,
247 .print
= print_hex64
,
252 static int parse_string(DeviceState
*dev
, Property
*prop
, const char *str
)
254 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
258 *ptr
= qemu_strdup(str
);
262 static void free_string(DeviceState
*dev
, Property
*prop
)
264 qemu_free(*(char **)qdev_get_prop_ptr(dev
, prop
));
267 static int print_string(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
269 char **ptr
= qdev_get_prop_ptr(dev
, prop
);
271 return snprintf(dest
, len
, "<null>");
272 return snprintf(dest
, len
, "\"%s\"", *ptr
);
275 PropertyInfo qdev_prop_string
= {
277 .type
= PROP_TYPE_STRING
,
278 .size
= sizeof(char*),
279 .parse
= parse_string
,
280 .print
= print_string
,
286 static int parse_drive(DeviceState
*dev
, Property
*prop
, const char *str
)
288 DriveInfo
**ptr
= qdev_get_prop_ptr(dev
, prop
);
290 *ptr
= drive_get_by_id(str
);
296 static int print_drive(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
298 DriveInfo
**ptr
= qdev_get_prop_ptr(dev
, prop
);
299 return snprintf(dest
, len
, "%s", (*ptr
) ? (*ptr
)->id
: "<null>");
302 PropertyInfo qdev_prop_drive
= {
304 .type
= PROP_TYPE_DRIVE
,
305 .size
= sizeof(DriveInfo
*),
306 .parse
= parse_drive
,
307 .print
= print_drive
,
310 /* --- character device --- */
312 static int parse_chr(DeviceState
*dev
, Property
*prop
, const char *str
)
314 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
316 *ptr
= qemu_chr_find(str
);
322 static int print_chr(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
324 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
326 if (*ptr
&& (*ptr
)->label
) {
327 return snprintf(dest
, len
, "%s", (*ptr
)->label
);
329 return snprintf(dest
, len
, "<null>");
333 PropertyInfo qdev_prop_chr
= {
335 .type
= PROP_TYPE_CHR
,
336 .size
= sizeof(CharDriverState
*),
341 /* --- netdev device --- */
343 static int parse_netdev(DeviceState
*dev
, Property
*prop
, const char *str
)
345 VLANClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
347 *ptr
= qemu_find_netdev(str
);
356 static int print_netdev(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
358 VLANClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
360 if (*ptr
&& (*ptr
)->name
) {
361 return snprintf(dest
, len
, "%s", (*ptr
)->name
);
363 return snprintf(dest
, len
, "<null>");
367 PropertyInfo qdev_prop_netdev
= {
369 .type
= PROP_TYPE_NETDEV
,
370 .size
= sizeof(VLANClientState
*),
371 .parse
= parse_netdev
,
372 .print
= print_netdev
,
377 static int parse_vlan(DeviceState
*dev
, Property
*prop
, const char *str
)
379 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
382 if (sscanf(str
, "%d", &id
) != 1)
384 *ptr
= qemu_find_vlan(id
, 1);
390 static int print_vlan(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
392 VLANState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
395 return snprintf(dest
, len
, "%d", (*ptr
)->id
);
397 return snprintf(dest
, len
, "<null>");
401 PropertyInfo qdev_prop_vlan
= {
403 .type
= PROP_TYPE_VLAN
,
404 .size
= sizeof(VLANClientState
*),
409 /* --- pointer --- */
411 /* Not a proper property, just for dirty hacks. TODO Remove it! */
412 PropertyInfo qdev_prop_ptr
= {
414 .type
= PROP_TYPE_PTR
,
415 .size
= sizeof(void*),
418 /* --- mac address --- */
421 * accepted syntax versions:
425 static int parse_mac(DeviceState
*dev
, Property
*prop
, const char *str
)
427 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
431 for (i
= 0, pos
= 0; i
< 6; i
++, pos
+= 3) {
432 if (!qemu_isxdigit(str
[pos
]))
434 if (!qemu_isxdigit(str
[pos
+1]))
437 if (str
[pos
+2] != '\0')
440 if (str
[pos
+2] != ':' && str
[pos
+2] != '-')
443 mac
->a
[i
] = strtol(str
+pos
, &p
, 16);
448 static int print_mac(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
450 MACAddr
*mac
= qdev_get_prop_ptr(dev
, prop
);
452 return snprintf(dest
, len
, "%02x:%02x:%02x:%02x:%02x:%02x",
453 mac
->a
[0], mac
->a
[1], mac
->a
[2],
454 mac
->a
[3], mac
->a
[4], mac
->a
[5]);
457 PropertyInfo qdev_prop_macaddr
= {
459 .type
= PROP_TYPE_MACADDR
,
460 .size
= sizeof(MACAddr
),
465 /* --- pci address --- */
468 * bus-local address, i.e. "$slot" or "$slot.$fn"
470 static int parse_pci_devfn(DeviceState
*dev
, Property
*prop
, const char *str
)
472 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
473 unsigned int slot
, fn
, n
;
475 if (sscanf(str
, "%x.%x%n", &slot
, &fn
, &n
) != 2) {
477 if (sscanf(str
, "%x%n", &slot
, &n
) != 1) {
485 *ptr
= slot
<< 3 | fn
;
489 static int print_pci_devfn(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
491 uint32_t *ptr
= qdev_get_prop_ptr(dev
, prop
);
494 return snprintf(dest
, len
, "<unset>");
496 return snprintf(dest
, len
, "%02x.%x", *ptr
>> 3, *ptr
& 7);
500 PropertyInfo qdev_prop_pci_devfn
= {
502 .type
= PROP_TYPE_UINT32
,
503 .size
= sizeof(uint32_t),
504 .parse
= parse_pci_devfn
,
505 .print
= print_pci_devfn
,
508 /* --- public helpers --- */
510 static Property
*qdev_prop_walk(Property
*props
, const char *name
)
514 while (props
->name
) {
515 if (strcmp(props
->name
, name
) == 0)
522 static Property
*qdev_prop_find(DeviceState
*dev
, const char *name
)
526 /* device properties */
527 prop
= qdev_prop_walk(dev
->info
->props
, name
);
532 prop
= qdev_prop_walk(dev
->parent_bus
->info
->props
, name
);
539 int qdev_prop_exists(DeviceState
*dev
, const char *name
)
541 return qdev_prop_find(dev
, name
) ? true : false;
544 int qdev_prop_parse(DeviceState
*dev
, const char *name
, const char *value
)
549 prop
= qdev_prop_find(dev
, name
);
551 * TODO Properties without a parse method are just for dirty
552 * hacks. qdev_prop_ptr is the only such PropertyInfo. It's
553 * marked for removal. The test !prop->info->parse should be
554 * removed along with it.
556 if (!prop
|| !prop
->info
->parse
) {
557 qerror_report(QERR_PROPERTY_NOT_FOUND
, dev
->info
->name
, name
);
560 ret
= prop
->info
->parse(dev
, prop
, value
);
564 qerror_report(QERR_PROPERTY_VALUE_IN_USE
,
565 dev
->info
->name
, name
, value
);
569 qerror_report(QERR_PROPERTY_VALUE_BAD
,
570 dev
->info
->name
, name
, value
);
573 qerror_report(QERR_PROPERTY_VALUE_NOT_FOUND
,
574 dev
->info
->name
, name
, value
);
582 void qdev_prop_set(DeviceState
*dev
, const char *name
, void *src
, enum PropertyType type
)
586 prop
= qdev_prop_find(dev
, name
);
588 fprintf(stderr
, "%s: property \"%s.%s\" not found\n",
589 __FUNCTION__
, dev
->info
->name
, name
);
592 if (prop
->info
->type
!= type
) {
593 fprintf(stderr
, "%s: property \"%s.%s\" type mismatch\n",
594 __FUNCTION__
, dev
->info
->name
, name
);
597 qdev_prop_cpy(dev
, prop
, src
);
600 void qdev_prop_set_uint8(DeviceState
*dev
, const char *name
, uint8_t value
)
602 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT8
);
605 void qdev_prop_set_uint16(DeviceState
*dev
, const char *name
, uint16_t value
)
607 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT16
);
610 void qdev_prop_set_uint32(DeviceState
*dev
, const char *name
, uint32_t value
)
612 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT32
);
615 void qdev_prop_set_int32(DeviceState
*dev
, const char *name
, int32_t value
)
617 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_INT32
);
620 void qdev_prop_set_uint64(DeviceState
*dev
, const char *name
, uint64_t value
)
622 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_UINT64
);
625 void qdev_prop_set_string(DeviceState
*dev
, const char *name
, char *value
)
627 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_STRING
);
630 void qdev_prop_set_drive(DeviceState
*dev
, const char *name
, DriveInfo
*value
)
632 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_DRIVE
);
635 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
, CharDriverState
*value
)
637 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_CHR
);
640 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
, VLANClientState
*value
)
642 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_NETDEV
);
645 void qdev_prop_set_vlan(DeviceState
*dev
, const char *name
, VLANState
*value
)
647 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_VLAN
);
650 void qdev_prop_set_macaddr(DeviceState
*dev
, const char *name
, uint8_t *value
)
652 qdev_prop_set(dev
, name
, value
, PROP_TYPE_MACADDR
);
655 void qdev_prop_set_ptr(DeviceState
*dev
, const char *name
, void *value
)
657 qdev_prop_set(dev
, name
, &value
, PROP_TYPE_PTR
);
660 void qdev_prop_set_defaults(DeviceState
*dev
, Property
*props
)
664 while (props
->name
) {
666 qdev_prop_cpy(dev
, props
, props
->defval
);
672 static QTAILQ_HEAD(, GlobalProperty
) global_props
= QTAILQ_HEAD_INITIALIZER(global_props
);
674 static void qdev_prop_register_global(GlobalProperty
*prop
)
676 QTAILQ_INSERT_TAIL(&global_props
, prop
, next
);
679 void qdev_prop_register_global_list(GlobalProperty
*props
)
683 for (i
= 0; props
[i
].driver
!= NULL
; i
++) {
684 qdev_prop_register_global(props
+i
);
688 void qdev_prop_set_globals(DeviceState
*dev
)
690 GlobalProperty
*prop
;
692 QTAILQ_FOREACH(prop
, &global_props
, next
) {
693 if (strcmp(dev
->info
->name
, prop
->driver
) != 0 &&
694 strcmp(dev
->info
->bus_info
->name
, prop
->driver
) != 0) {
697 if (qdev_prop_parse(dev
, prop
->property
, prop
->value
) != 0) {
703 static int qdev_add_one_global(QemuOpts
*opts
, void *opaque
)
707 g
= qemu_mallocz(sizeof(*g
));
708 g
->driver
= qemu_opt_get(opts
, "driver");
709 g
->property
= qemu_opt_get(opts
, "property");
710 g
->value
= qemu_opt_get(opts
, "value");
711 qdev_prop_register_global(g
);
715 void qemu_add_globals(void)
717 qemu_opts_foreach(&qemu_global_opts
, qdev_add_one_global
, NULL
, 0);