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.
15 #include "qapi/qmp/qerror.h"
16 #include "sysemu/block-backend.h"
17 #include "sysemu/blockdev.h"
18 #include "hw/block/block.h"
20 #include "qapi/visitor.h"
21 #include "sysemu/char.h"
22 #include "sysemu/iothread.h"
24 static void get_pointer(Object
*obj
, Visitor
*v
, Property
*prop
,
25 char *(*print
)(void *ptr
),
26 const char *name
, Error
**errp
)
28 DeviceState
*dev
= DEVICE(obj
);
29 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
32 p
= *ptr
? print(*ptr
) : g_strdup("");
33 visit_type_str(v
, &p
, name
, errp
);
37 static void set_pointer(Object
*obj
, Visitor
*v
, Property
*prop
,
38 int (*parse
)(DeviceState
*dev
, const char *str
,
40 const char *name
, Error
**errp
)
42 DeviceState
*dev
= DEVICE(obj
);
43 Error
*local_err
= NULL
;
44 void **ptr
= qdev_get_prop_ptr(dev
, prop
);
49 qdev_prop_set_after_realize(dev
, name
, errp
);
53 visit_type_str(v
, &str
, name
, &local_err
);
55 error_propagate(errp
, local_err
);
63 ret
= parse(dev
, str
, ptr
);
64 error_set_from_qdev_prop_error(errp
, ret
, dev
, prop
, str
);
70 static int parse_drive(DeviceState
*dev
, const char *str
, void **ptr
)
74 blk
= blk_by_name(str
);
78 if (blk_attach_dev(blk
, dev
) < 0) {
85 static void release_drive(Object
*obj
, const char *name
, void *opaque
)
87 DeviceState
*dev
= DEVICE(obj
);
88 Property
*prop
= opaque
;
89 BlockBackend
**ptr
= qdev_get_prop_ptr(dev
, prop
);
92 blk_detach_dev(*ptr
, dev
);
93 blockdev_auto_del(*ptr
);
97 static char *print_drive(void *ptr
)
99 return g_strdup(blk_name(ptr
));
102 static void get_drive(Object
*obj
, Visitor
*v
, void *opaque
,
103 const char *name
, Error
**errp
)
105 get_pointer(obj
, v
, opaque
, print_drive
, name
, errp
);
108 static void set_drive(Object
*obj
, Visitor
*v
, void *opaque
,
109 const char *name
, Error
**errp
)
111 set_pointer(obj
, v
, opaque
, parse_drive
, name
, errp
);
114 PropertyInfo qdev_prop_drive
= {
116 .description
= "ID of a drive to use as a backend",
119 .release
= release_drive
,
122 /* --- character device --- */
124 static int parse_chr(DeviceState
*dev
, const char *str
, void **ptr
)
126 CharDriverState
*chr
= qemu_chr_find(str
);
130 if (qemu_chr_fe_claim(chr
) != 0) {
137 static void release_chr(Object
*obj
, const char *name
, void *opaque
)
139 DeviceState
*dev
= DEVICE(obj
);
140 Property
*prop
= opaque
;
141 CharDriverState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
142 CharDriverState
*chr
= *ptr
;
145 qemu_chr_add_handlers(chr
, NULL
, NULL
, NULL
, NULL
);
146 qemu_chr_fe_release(chr
);
151 static char *print_chr(void *ptr
)
153 CharDriverState
*chr
= ptr
;
154 const char *val
= chr
->label
? chr
->label
: "";
156 return g_strdup(val
);
159 static void get_chr(Object
*obj
, Visitor
*v
, void *opaque
,
160 const char *name
, Error
**errp
)
162 get_pointer(obj
, v
, opaque
, print_chr
, name
, errp
);
165 static void set_chr(Object
*obj
, Visitor
*v
, void *opaque
,
166 const char *name
, Error
**errp
)
168 set_pointer(obj
, v
, opaque
, parse_chr
, name
, errp
);
171 PropertyInfo qdev_prop_chr
= {
173 .description
= "ID of a chardev to use as a backend",
176 .release
= release_chr
,
179 /* --- netdev device --- */
181 static int parse_netdev(DeviceState
*dev
, const char *str
, void **ptr
)
183 NICPeers
*peers_ptr
= (NICPeers
*)ptr
;
184 NetClientState
**ncs
= peers_ptr
->ncs
;
185 NetClientState
*peers
[MAX_QUEUE_NUM
];
189 queues
= qemu_find_net_clients_except(str
, peers
,
190 NET_CLIENT_OPTIONS_KIND_NIC
,
197 if (queues
> MAX_QUEUE_NUM
) {
202 for (i
= 0; i
< queues
; i
++) {
203 if (peers
[i
] == NULL
) {
208 if (peers
[i
]->peer
) {
219 ncs
[i
]->queue_index
= i
;
222 peers_ptr
->queues
= queues
;
230 static char *print_netdev(void *ptr
)
232 NetClientState
*netdev
= ptr
;
233 const char *val
= netdev
->name
? netdev
->name
: "";
235 return g_strdup(val
);
238 static void get_netdev(Object
*obj
, Visitor
*v
, void *opaque
,
239 const char *name
, Error
**errp
)
241 get_pointer(obj
, v
, opaque
, print_netdev
, name
, errp
);
244 static void set_netdev(Object
*obj
, Visitor
*v
, void *opaque
,
245 const char *name
, Error
**errp
)
247 set_pointer(obj
, v
, opaque
, parse_netdev
, name
, errp
);
250 PropertyInfo qdev_prop_netdev
= {
252 .description
= "ID of a netdev to use as a backend",
259 static int print_vlan(DeviceState
*dev
, Property
*prop
, char *dest
, size_t len
)
261 NetClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
265 if (!net_hub_id_for_client(*ptr
, &id
)) {
266 return snprintf(dest
, len
, "%d", id
);
270 return snprintf(dest
, len
, "<null>");
273 static void get_vlan(Object
*obj
, Visitor
*v
, void *opaque
,
274 const char *name
, Error
**errp
)
276 DeviceState
*dev
= DEVICE(obj
);
277 Property
*prop
= opaque
;
278 NetClientState
**ptr
= qdev_get_prop_ptr(dev
, prop
);
283 if (!net_hub_id_for_client(*ptr
, &hub_id
)) {
288 visit_type_int32(v
, &id
, name
, errp
);
291 static void set_vlan(Object
*obj
, Visitor
*v
, void *opaque
,
292 const char *name
, Error
**errp
)
294 DeviceState
*dev
= DEVICE(obj
);
295 Property
*prop
= opaque
;
296 NICPeers
*peers_ptr
= qdev_get_prop_ptr(dev
, prop
);
297 NetClientState
**ptr
= &peers_ptr
->ncs
[0];
298 Error
*local_err
= NULL
;
300 NetClientState
*hubport
;
303 qdev_prop_set_after_realize(dev
, name
, errp
);
307 visit_type_int32(v
, &id
, name
, &local_err
);
309 error_propagate(errp
, local_err
);
317 error_set_from_qdev_prop_error(errp
, -EINVAL
, dev
, prop
, name
);
321 hubport
= net_hub_port_find(id
);
323 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
,
324 name
, prop
->info
->name
);
330 PropertyInfo qdev_prop_vlan
= {
332 .description
= "Integer VLAN id to connect to",
338 int qdev_prop_set_drive(DeviceState
*dev
, const char *name
,
342 object_property_set_str(OBJECT(dev
),
343 value
? blk_name(value
) : "", name
, &err
);
345 qerror_report_err(err
);
352 void qdev_prop_set_drive_nofail(DeviceState
*dev
, const char *name
,
355 if (qdev_prop_set_drive(dev
, name
, value
) < 0) {
359 void qdev_prop_set_chr(DeviceState
*dev
, const char *name
,
360 CharDriverState
*value
)
362 assert(!value
|| value
->label
);
363 object_property_set_str(OBJECT(dev
),
364 value
? value
->label
: "", name
, &error_abort
);
367 void qdev_prop_set_netdev(DeviceState
*dev
, const char *name
,
368 NetClientState
*value
)
370 assert(!value
|| value
->name
);
371 object_property_set_str(OBJECT(dev
),
372 value
? value
->name
: "", name
, &error_abort
);
375 void qdev_set_nic_properties(DeviceState
*dev
, NICInfo
*nd
)
377 qdev_prop_set_macaddr(dev
, "mac", nd
->macaddr
.a
);
379 qdev_prop_set_netdev(dev
, "netdev", nd
->netdev
);
381 if (nd
->nvectors
!= DEV_NVECTORS_UNSPECIFIED
&&
382 object_property_find(OBJECT(dev
), "vectors", NULL
)) {
383 qdev_prop_set_uint32(dev
, "vectors", nd
->nvectors
);
385 nd
->instantiated
= 1;
388 static int qdev_add_one_global(QemuOpts
*opts
, void *opaque
)
392 g
= g_malloc0(sizeof(*g
));
393 g
->driver
= qemu_opt_get(opts
, "driver");
394 g
->property
= qemu_opt_get(opts
, "property");
395 g
->value
= qemu_opt_get(opts
, "value");
396 g
->user_provided
= true;
397 qdev_prop_register_global(g
);
401 void qemu_add_globals(void)
403 qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global
, NULL
, 0);