2 * qdev property parsing and global properties
3 * (parts specific for qemu-system-*)
5 * This file is based on code from hw/qdev-properties.c from
6 * commit 074a86fccd185616469dfcdc0e157f438aebba18,
7 * Copyright (c) Gerd Hoffmann <kraxel@redhat.com> and other contributors.
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
16 #include "qapi/qmp/qerror.h"
17 #include "sysemu/block-backend.h"
18 #include "sysemu/blockdev.h"
19 #include "hw/block/block.h"
21 #include "qapi/visitor.h"
22 #include "sysemu/char.h"
23 #include "sysemu/iothread.h"
25 static void get_pointer(Object
*obj
, Visitor
*v
, Property
*prop
,
26 char *(*print
)(void *ptr
),
27 const char *name
, Error
**errp
)
29 DeviceState
*dev
= DEVICE(obj
);
30 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
33 p
= *ptr
? print(*ptr
) : g_strdup("");
34 visit_type_str(v
, &p
, name
, errp
);
38 static void set_pointer(Object
*obj
, Visitor
*v
, Property
*prop
,
39 void (*parse
)(DeviceState
*dev
, const char *str
,
40 void **ptr
, const char *propname
,
42 const char *name
, Error
**errp
)
44 DeviceState
*dev
= DEVICE(obj
);
45 Error
*local_err
= NULL
;
46 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
50 qdev_prop_set_after_realize(dev
, name
, errp
);
54 visit_type_str(v
, &str
, name
, &local_err
);
56 error_propagate(errp
, local_err
);
64 parse(dev
, str
, ptr
, prop
->name
, errp
);
70 static void parse_drive(DeviceState
*dev
, const char *str
, void **ptr
,
71 const char *propname
, Error
**errp
)
75 blk
= blk_by_name(str
);
77 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
78 object_get_typename(OBJECT(dev
)), propname
, str
);
81 if (blk_attach_dev(blk
, dev
) < 0) {
82 DriveInfo
*dinfo
= blk_legacy_dinfo(blk
);
84 if (dinfo
->type
!= IF_NONE
) {
85 error_setg(errp
, "Drive '%s' is already in use because "
86 "it has been automatically connected to another "
87 "device (did you need 'if=none' in the drive options?)",
90 error_setg(errp
, "Drive '%s' is already in use by another device",
98 static void release_drive(Object
*obj
, const char *name
, void *opaque
)
100 DeviceState
*dev
= DEVICE(obj
);
101 Property
*prop
= opaque
;
102 BlockBackend
**ptr
= qdev_get_prop_ptr(dev
, prop
);
105 blk_detach_dev(*ptr
, dev
);
106 blockdev_auto_del(*ptr
);
110 static char *print_drive(void *ptr
)
112 return g_strdup(blk_name(ptr
));
115 static void get_drive(Object
*obj
, Visitor
*v
, void *opaque
,
116 const char *name
, Error
**errp
)
118 get_pointer(obj
, v
, opaque
, print_drive
, name
, errp
);
121 static void set_drive(Object
*obj
, Visitor
*v
, void *opaque
,
122 const char *name
, Error
**errp
)
124 set_pointer(obj
, v
, opaque
, parse_drive
, name
, errp
);
127 PropertyInfo qdev_prop_drive
= {
129 .description
= "ID of a drive to use as a backend",
132 .release
= release_drive
,
135 /* --- character device --- */
137 static void parse_chr(DeviceState
*dev
, const char *str
, void **ptr
,
138 const char *propname
, Error
**errp
)
140 CharDriverState
*chr
= qemu_chr_find(str
);
142 error_setg(errp
, "Property '%s.%s' can't find value '%s'",
143 object_get_typename(OBJECT(dev
)), propname
, str
);
146 if (qemu_chr_fe_claim(chr
) != 0) {
147 error_setg(errp
, "Property '%s.%s' can't take value '%s', it's in use",
148 object_get_typename(OBJECT(dev
)), propname
, str
);
154 static void release_chr(Object
*obj
, const char *name
, void *opaque
)
156 DeviceState
*dev
= DEVICE(obj
);
157 Property
*prop
= opaque
;
158 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
159 CharDriverState
*chr
= *ptr
;
162 qemu_chr_add_handlers(chr
, NULL
, NULL
, NULL
, NULL
);
163 qemu_chr_fe_release(chr
);
168 static char *print_chr(void *ptr
)
170 CharDriverState
*chr
= ptr
;
171 const char *val
= chr
->label
? chr
->label
: "";
173 return g_strdup(val
);
176 static void get_chr(Object
*obj
, Visitor
*v
, void *opaque
,
177 const char *name
, Error
**errp
)
179 get_pointer(obj
, v
, opaque
, print_chr
, name
, errp
);
182 static void set_chr(Object
*obj
, Visitor
*v
, void *opaque
,
183 const char *name
, Error
**errp
)
185 set_pointer(obj
, v
, opaque
, parse_chr
, name
, errp
);
188 PropertyInfo qdev_prop_chr
= {
190 .description
= "ID of a chardev to use as a backend",
193 .release
= release_chr
,
196 /* --- netdev device --- */
197 static void get_netdev(Object
*obj
, Visitor
*v
, void *opaque
,
198 const char *name
, Error
**errp
)
200 DeviceState
*dev
= DEVICE(obj
);
201 Property
*prop
= opaque
;
202 NICPeers
*peers_ptr
= qdev_get_prop_ptr(dev
, prop
);
203 char *p
= g_strdup(peers_ptr
->ncs
[0] ? peers_ptr
->ncs
[0]->name
: "");
205 visit_type_str(v
, &p
, name
, errp
);
209 static void set_netdev(Object
*obj
, Visitor
*v
, void *opaque
,
210 const char *name
, Error
**errp
)
212 DeviceState
*dev
= DEVICE(obj
);
213 Property
*prop
= opaque
;
214 NICPeers
*peers_ptr
= qdev_get_prop_ptr(dev
, prop
);
215 NetClientState
**ncs
= peers_ptr
->ncs
;
216 NetClientState
*peers
[MAX_QUEUE_NUM
];
217 Error
*local_err
= NULL
;
218 int queues
, err
= 0, i
= 0;
222 qdev_prop_set_after_realize(dev
, name
, errp
);
226 visit_type_str(v
, &str
, name
, &local_err
);
228 error_propagate(errp
, local_err
);
232 queues
= qemu_find_net_clients_except(str
, peers
,
233 NET_CLIENT_OPTIONS_KIND_NIC
,
240 if (queues
> MAX_QUEUE_NUM
) {
241 error_setg(errp
, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)",
242 str
, queues
, MAX_QUEUE_NUM
);
246 for (i
= 0; i
< queues
; i
++) {
247 if (peers
[i
] == NULL
) {
252 if (peers
[i
]->peer
) {
263 ncs
[i
]->queue_index
= i
;
266 peers_ptr
->queues
= queues
;
269 error_set_from_qdev_prop_error(errp
, err
, dev
, prop
, str
);
273 PropertyInfo qdev_prop_netdev
= {
275 .description
= "ID of a netdev to use as a backend",
282 static int print_vlan(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
284 NetClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
288 if (!net_hub_id_for_client(*ptr
, &id
)) {
289 return snprintf(dest
, len
, "%d", id
);
293 return snprintf(dest
, len
, "<null>");
296 static void get_vlan(Object
*obj
, Visitor
*v
, void *opaque
,
297 const char *name
, Error
**errp
)
299 DeviceState
*dev
= DEVICE(obj
);
300 Property
*prop
= opaque
;
301 NetClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
306 if (!net_hub_id_for_client(*ptr
, &hub_id
)) {
311 visit_type_int32(v
, &id
, name
, errp
);
314 static void set_vlan(Object
*obj
, Visitor
*v
, void *opaque
,
315 const char *name
, Error
**errp
)
317 DeviceState
*dev
= DEVICE(obj
);
318 Property
*prop
= opaque
;
319 NICPeers
*peers_ptr
= qdev_get_prop_ptr(dev
, prop
);
320 NetClientState
**ptr
= &peers_ptr
->ncs
[0];
321 Error
*local_err
= NULL
;
323 NetClientState
*hubport
;
326 qdev_prop_set_after_realize(dev
, name
, errp
);
330 visit_type_int32(v
, &id
, name
, &local_err
);
332 error_propagate(errp
, local_err
);
340 error_set_from_qdev_prop_error(errp
, -EINVAL
, dev
, prop
, name
);
344 hubport
= net_hub_port_find(id
);
346 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
347 name
, prop
->info
->name
);
353 PropertyInfo qdev_prop_vlan
= {
355 .description
= "Integer VLAN id to connect to",
361 void qdev_prop_set_drive(DeviceState
*dev
, const char *name
,
362 BlockBackend
*value
, Error
**errp
)
364 object_property_set_str(OBJECT(dev
), value
? blk_name(value
) : "",
368 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
,
369 CharDriverState
*value
)
371 assert(!value
|| value
->label
);
372 object_property_set_str(OBJECT(dev
),
373 value
? value
->label
: "", name
, &error_abort
);
376 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
,
377 NetClientState
*value
)
379 assert(!value
|| value
->name
);
380 object_property_set_str(OBJECT(dev
),
381 value
? value
->name
: "", name
, &error_abort
);
384 void qdev_set_nic_properties(DeviceState
*dev
, NICInfo
*nd
)
386 qdev_prop_set_macaddr(dev
, "mac", nd
->macaddr
.a
);
388 qdev_prop_set_netdev(dev
, "netdev", nd
->netdev
);
390 if (nd
->nvectors
!= DEV_NVECTORS_UNSPECIFIED
&&
391 object_property_find(OBJECT(dev
), "vectors", NULL
)) {
392 qdev_prop_set_uint32(dev
, "vectors", nd
->nvectors
);
394 nd
->instantiated
= 1;
397 static int qdev_add_one_global(void *opaque
, QemuOpts
*opts
, Error
**errp
)
401 g
= g_malloc0(sizeof(*g
));
402 g
->driver
= qemu_opt_get(opts
, "driver");
403 g
->property
= qemu_opt_get(opts
, "property");
404 g
->value
= qemu_opt_get(opts
, "value");
405 g
->user_provided
= true;
406 qdev_prop_register_global(g
);
410 void qemu_add_globals(void)
412 qemu_opts_foreach(qemu_find_opts("global"),
413 qdev_add_one_global
, NULL
, NULL
);