1 /*
2 * qdev property parsing
3 * (parts specific for qemu-system-*)
4 *
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.
8 *
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.
11 */
12
13 #include "qemu/osdep.h"
14 #include "hw/qdev-properties.h"
15 #include "hw/qdev-properties-system.h"
16 #include "qapi/error.h"
17 #include "qapi/visitor.h"
18 #include "qapi/qapi-types-block.h"
19 #include "qapi/qapi-types-machine.h"
20 #include "qapi/qapi-types-migration.h"
21 #include "qapi/qapi-visit-virtio.h"
22 #include "qapi/qmp/qerror.h"
23 #include "qemu/ctype.h"
24 #include "qemu/cutils.h"
25 #include "qemu/units.h"
26 #include "qemu/uuid.h"
27 #include "qemu/error-report.h"
28 #include "qdev-prop-internal.h"
29
30 #include "audio/audio.h"
31 #include "chardev/char-fe.h"
32 #include "sysemu/block-backend.h"
33 #include "sysemu/blockdev.h"
34 #include "net/net.h"
35 #include "hw/pci/pci.h"
36 #include "hw/pci/pcie.h"
37 #include "hw/i386/x86.h"
38 #include "util/block-helpers.h"
39
check_prop_still_unset(Object * obj,const char * name,const void * old_val,const char * new_val,bool allow_override,Error ** errp)40 static bool check_prop_still_unset(Object *obj, const char *name,
41 const void *old_val, const char *new_val,
42 bool allow_override, Error **errp)
43 {
44 const GlobalProperty *prop = qdev_find_global_prop(obj, name);
45
46 if (!old_val || (!prop && allow_override)) {
47 return true;
48 }
49
50 if (prop) {
51 error_setg(errp, "-global %s.%s=... conflicts with %s=%s",
52 prop->driver, prop->property, name, new_val);
53 } else {
54 /* Error message is vague, but a better one would be hard */
55 error_setg(errp, "%s=%s conflicts, and override is not implemented",
56 name, new_val);
57 }
58 return false;
59 }
60
61
62 /* --- drive --- */
63
get_drive(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)64 static void get_drive(Object *obj, Visitor *v, const char *name, void *opaque,
65 Error **errp)
66 {
67 Property *prop = opaque;
68 void **ptr = object_field_prop_ptr(obj, prop);
69 const char *value;
70 char *p;
71
72 if (*ptr) {
73 value = blk_name(*ptr);
74 if (!*value) {
75 BlockDriverState *bs = blk_bs(*ptr);
76 if (bs) {
77 value = bdrv_get_node_name(bs);
78 }
79 }
80 } else {
81 value = "";
82 }
83
84 p = g_strdup(value);
85 visit_type_str(v, name, &p, errp);
86 g_free(p);
87 }
88
set_drive_helper(Object * obj,Visitor * v,const char * name,void * opaque,bool iothread,Error ** errp)89 static void set_drive_helper(Object *obj, Visitor *v, const char *name,
90 void *opaque, bool iothread, Error **errp)
91 {
92 DeviceState *dev = DEVICE(obj);
93 Property *prop = opaque;
94 void **ptr = object_field_prop_ptr(obj, prop);
95 char *str;
96 BlockBackend *blk;
97 bool blk_created = false;
98 int ret;
99 BlockDriverState *bs;
100 AioContext *ctx;
101
102 if (!visit_type_str(v, name, &str, errp)) {
103 return;
104 }
105
106 if (!check_prop_still_unset(obj, name, *ptr, str, true, errp)) {
107 return;
108 }
109
110 if (*ptr) {
111 /* BlockBackend already exists. So, we want to change attached node */
112 blk = *ptr;
113 ctx = blk_get_aio_context(blk);
114 bs = bdrv_lookup_bs(NULL, str, errp);
115 if (!bs) {
116 return;
117 }
118
119 if (ctx != bdrv_get_aio_context(bs)) {
120 error_setg(errp, "Different aio context is not supported for new "
121 "node");
122 }
123
124 blk_replace_bs(blk, bs, errp);
125 return;
126 }
127
128 if (!*str) {
129 g_free(str);
130 *ptr = NULL;
131 return;
132 }
133
134 blk = blk_by_name(str);
135 if (!blk) {
136 bs = bdrv_lookup_bs(NULL, str, NULL);
137 if (bs) {
138 /*
139 * If the device supports iothreads, it will make sure to move the
140 * block node to the right AioContext if necessary (or fail if this
141 * isn't possible because of other users). Devices that are not
142 * aware of iothreads require their BlockBackends to be in the main
143 * AioContext.
144 */
145 ctx = bdrv_get_aio_context(bs);
146 blk = blk_new(iothread ? ctx : qemu_get_aio_context(),
147 0, BLK_PERM_ALL);
148 blk_created = true;
149
150 ret = blk_insert_bs(blk, bs, errp);
151 if (ret < 0) {
152 goto fail;
153 }
154 }
155 }
156 if (!blk) {
157 error_setg(errp, "Property '%s.%s' can't find value '%s'",
158 object_get_typename(OBJECT(dev)), name, str);
159 goto fail;
160 }
161 if (blk_attach_dev(blk, dev) < 0) {
162 DriveInfo *dinfo = blk_legacy_dinfo(blk);
163
164 if (dinfo && dinfo->type != IF_NONE) {
165 error_setg(errp, "Drive '%s' is already in use because "
166 "it has been automatically connected to another "
167 "device (did you need 'if=none' in the drive options?)",
168 str);
169 } else {
170 error_setg(errp, "Drive '%s' is already in use by another device",
171 str);
172 }
173 goto fail;
174 }
175
176 *ptr = blk;
177
178 fail:
179 if (blk_created) {
180 /* If we need to keep a reference, blk_attach_dev() took it */
181 blk_unref(blk);
182 }
183
184 g_free(str);
185 }
186
set_drive(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)187 static void set_drive(Object *obj, Visitor *v, const char *name, void *opaque,
188 Error **errp)
189 {
190 set_drive_helper(obj, v, name, opaque, false, errp);
191 }
192
set_drive_iothread(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)193 static void set_drive_iothread(Object *obj, Visitor *v, const char *name,
194 void *opaque, Error **errp)
195 {
196 set_drive_helper(obj, v, name, opaque, true, errp);
197 }
198
release_drive(Object * obj,const char * name,void * opaque)199 static void release_drive(Object *obj, const char *name, void *opaque)
200 {
201 DeviceState *dev = DEVICE(obj);
202 Property *prop = opaque;
203 BlockBackend **ptr = object_field_prop_ptr(obj, prop);
204
205 if (*ptr) {
206 blockdev_auto_del(*ptr);
207 blk_detach_dev(*ptr, dev);
208 }
209 }
210
211 const PropertyInfo qdev_prop_drive = {
212 .name = "str",
213 .description = "Node name or ID of a block device to use as a backend",
214 .realized_set_allowed = true,
215 .get = get_drive,
216 .set = set_drive,
217 .release = release_drive,
218 };
219
220 const PropertyInfo qdev_prop_drive_iothread = {
221 .name = "str",
222 .description = "Node name or ID of a block device to use as a backend",
223 .realized_set_allowed = true,
224 .get = get_drive,
225 .set = set_drive_iothread,
226 .release = release_drive,
227 };
228
229 /* --- character device --- */
230
get_chr(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)231 static void get_chr(Object *obj, Visitor *v, const char *name, void *opaque,
232 Error **errp)
233 {
234 CharBackend *be = object_field_prop_ptr(obj, opaque);
235 char *p;
236
237 p = g_strdup(be->chr && be->chr->label ? be->chr->label : "");
238 visit_type_str(v, name, &p, errp);
239 g_free(p);
240 }
241
set_chr(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)242 static void set_chr(Object *obj, Visitor *v, const char *name, void *opaque,
243 Error **errp)
244 {
245 ERRP_GUARD();
246 Property *prop = opaque;
247 CharBackend *be = object_field_prop_ptr(obj, prop);
248 Chardev *s;
249 char *str;
250
251 if (!visit_type_str(v, name, &str, errp)) {
252 return;
253 }
254
255 /*
256 * TODO Should this really be an error? If no, the old value
257 * needs to be released before we store the new one.
258 */
259 if (!check_prop_still_unset(obj, name, be->chr, str, false, errp)) {
260 return;
261 }
262
263 if (!*str) {
264 g_free(str);
265 be->chr = NULL;
266 return;
267 }
268
269 s = qemu_chr_find(str);
270 if (s == NULL) {
271 error_setg(errp, "Property '%s.%s' can't find value '%s'",
272 object_get_typename(obj), name, str);
273 } else if (!qemu_chr_fe_init(be, s, errp)) {
274 error_prepend(errp, "Property '%s.%s' can't take value '%s': ",
275 object_get_typename(obj), name, str);
276 }
277 g_free(str);
278 }
279
release_chr(Object * obj,const char * name,void * opaque)280 static void release_chr(Object *obj, const char *name, void *opaque)
281 {
282 Property *prop = opaque;
283 CharBackend *be = object_field_prop_ptr(obj, prop);
284
285 qemu_chr_fe_deinit(be, false);
286 }
287
288 const PropertyInfo qdev_prop_chr = {
289 .name = "str",
290 .description = "ID of a chardev to use as a backend",
291 .get = get_chr,
292 .set = set_chr,
293 .release = release_chr,
294 };
295
296 /* --- mac address --- */
297
298 /*
299 * accepted syntax versions:
300 * 01:02:03:04:05:06
301 * 01-02-03-04-05-06
302 */
get_mac(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)303 static void get_mac(Object *obj, Visitor *v, const char *name, void *opaque,
304 Error **errp)
305 {
306 Property *prop = opaque;
307 MACAddr *mac = object_field_prop_ptr(obj, prop);
308 char buffer[2 * 6 + 5 + 1];
309 char *p = buffer;
310
311 snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
312 mac->a[0], mac->a[1], mac->a[2],
313 mac->a[3], mac->a[4], mac->a[5]);
314
315 visit_type_str(v, name, &p, errp);
316 }
317
set_mac(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)318 static void set_mac(Object *obj, Visitor *v, const char *name, void *opaque,
319 Error **errp)
320 {
321 Property *prop = opaque;
322 MACAddr *mac = object_field_prop_ptr(obj, prop);
323 int i, pos;
324 char *str;
325 const char *p;
326
327 if (!visit_type_str(v, name, &str, errp)) {
328 return;
329 }
330
331 for (i = 0, pos = 0; i < 6; i++, pos += 3) {
332 long val;
333
334 if (!qemu_isxdigit(str[pos])) {
335 goto inval;
336 }
337 if (!qemu_isxdigit(str[pos + 1])) {
338 goto inval;
339 }
340 if (i == 5) {
341 if (str[pos + 2] != '\0') {
342 goto inval;
343 }
344 } else {
345 if (str[pos + 2] != ':' && str[pos + 2] != '-') {
346 goto inval;
347 }
348 }
349 if (qemu_strtol(str + pos, &p, 16, &val) < 0 || val > 0xff) {
350 goto inval;
351 }
352 mac->a[i] = val;
353 }
354 g_free(str);
355 return;
356
357 inval:
358 error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
359 g_free(str);
360 }
361
362 const PropertyInfo qdev_prop_macaddr = {
363 .name = "str",
364 .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
365 .get = get_mac,
366 .set = set_mac,
367 };
368
qdev_prop_set_macaddr(DeviceState * dev,const char * name,const uint8_t * value)369 void qdev_prop_set_macaddr(DeviceState *dev, const char *name,
370 const uint8_t *value)
371 {
372 char str[2 * 6 + 5 + 1];
373 snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
374 value[0], value[1], value[2], value[3], value[4], value[5]);
375
376 object_property_set_str(OBJECT(dev), name, str, &error_abort);
377 }
378
379 /* --- netdev device --- */
get_netdev(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)380 static void get_netdev(Object *obj, Visitor *v, const char *name,
381 void *opaque, Error **errp)
382 {
383 Property *prop = opaque;
384 NICPeers *peers_ptr = object_field_prop_ptr(obj, prop);
385 char *p = g_strdup(peers_ptr->ncs[0] ? peers_ptr->ncs[0]->name : "");
386
387 visit_type_str(v, name, &p, errp);
388 g_free(p);
389 }
390
set_netdev(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)391 static void set_netdev(Object *obj, Visitor *v, const char *name,
392 void *opaque, Error **errp)
393 {
394 Property *prop = opaque;
395 NICPeers *peers_ptr = object_field_prop_ptr(obj, prop);
396 NetClientState **ncs = peers_ptr->ncs;
397 NetClientState *peers[MAX_QUEUE_NUM];
398 int queues, err = 0, i = 0;
399 char *str;
400
401 if (!visit_type_str(v, name, &str, errp)) {
402 return;
403 }
404
405 queues = qemu_find_net_clients_except(str, peers,
406 NET_CLIENT_DRIVER_NIC,
407 MAX_QUEUE_NUM);
408 if (queues == 0) {
409 err = -ENOENT;
410 goto out;
411 }
412
413 if (queues > MAX_QUEUE_NUM) {
414 error_setg(errp, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)",
415 str, queues, MAX_QUEUE_NUM);
416 goto out;
417 }
418
419 for (i = 0; i < queues; i++) {
420 if (peers[i]->peer) {
421 err = -EEXIST;
422 goto out;
423 }
424
425 /*
426 * TODO Should this really be an error? If no, the old value
427 * needs to be released before we store the new one.
428 */
429 if (!check_prop_still_unset(obj, name, ncs[i], str, false, errp)) {
430 goto out;
431 }
432
433 if (peers[i]->info->check_peer_type) {
434 if (!peers[i]->info->check_peer_type(peers[i], obj->class, errp)) {
435 goto out;
436 }
437 }
438
439 ncs[i] = peers[i];
440 ncs[i]->queue_index = i;
441 }
442
443 peers_ptr->queues = queues;
444
445 out:
446 error_set_from_qdev_prop_error(errp, err, obj, prop->name, str);
447 g_free(str);
448 }
449
450 const PropertyInfo qdev_prop_netdev = {
451 .name = "str",
452 .description = "ID of a netdev to use as a backend",
453 .get = get_netdev,
454 .set = set_netdev,
455 };
456
457
458 /* --- audiodev --- */
get_audiodev(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)459 static void get_audiodev(Object *obj, Visitor *v, const char* name,
460 void *opaque, Error **errp)
461 {
462 Property *prop = opaque;
463 QEMUSoundCard *card = object_field_prop_ptr(obj, prop);
464 char *p = g_strdup(audio_get_id(card));
465
466 visit_type_str(v, name, &p, errp);
467 g_free(p);
468 }
469
set_audiodev(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)470 static void set_audiodev(Object *obj, Visitor *v, const char* name,
471 void *opaque, Error **errp)
472 {
473 Property *prop = opaque;
474 QEMUSoundCard *card = object_field_prop_ptr(obj, prop);
475 AudioState *state;
476 g_autofree char *str = NULL;
477
478 if (!visit_type_str(v, name, &str, errp)) {
479 return;
480 }
481
482 state = audio_state_by_name(str, errp);
483 if (state) {
484 card->state = state;
485 }
486 }
487
488 const PropertyInfo qdev_prop_audiodev = {
489 .name = "str",
490 .description = "ID of an audiodev to use as a backend",
491 /* release done on shutdown */
492 .get = get_audiodev,
493 .set = set_audiodev,
494 };
495
qdev_prop_set_drive_err(DeviceState * dev,const char * name,BlockBackend * value,Error ** errp)496 bool qdev_prop_set_drive_err(DeviceState *dev, const char *name,
497 BlockBackend *value, Error **errp)
498 {
499 const char *ref = "";
500
501 if (value) {
502 ref = blk_name(value);
503 if (!*ref) {
504 const BlockDriverState *bs = blk_bs(value);
505 if (bs) {
506 ref = bdrv_get_node_name(bs);
507 }
508 }
509 }
510
511 return object_property_set_str(OBJECT(dev), name, ref, errp);
512 }
513
qdev_prop_set_drive(DeviceState * dev,const char * name,BlockBackend * value)514 void qdev_prop_set_drive(DeviceState *dev, const char *name,
515 BlockBackend *value)
516 {
517 qdev_prop_set_drive_err(dev, name, value, &error_abort);
518 }
519
qdev_prop_set_chr(DeviceState * dev,const char * name,Chardev * value)520 void qdev_prop_set_chr(DeviceState *dev, const char *name,
521 Chardev *value)
522 {
523 assert(!value || value->label);
524 object_property_set_str(OBJECT(dev), name, value ? value->label : "",
525 &error_abort);
526 }
527
qdev_prop_set_netdev(DeviceState * dev,const char * name,NetClientState * value)528 void qdev_prop_set_netdev(DeviceState *dev, const char *name,
529 NetClientState *value)
530 {
531 assert(!value || value->name);
532 object_property_set_str(OBJECT(dev), name, value ? value->name : "",
533 &error_abort);
534 }
535
qdev_set_nic_properties(DeviceState * dev,NICInfo * nd)536 void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
537 {
538 qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
539 if (nd->netdev) {
540 qdev_prop_set_netdev(dev, "netdev", nd->netdev);
541 }
542 if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
543 object_property_find(OBJECT(dev), "vectors")) {
544 qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
545 }
546 nd->instantiated = 1;
547 }
548
549 /* --- lost tick policy --- */
550
qdev_propinfo_set_losttickpolicy(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)551 static void qdev_propinfo_set_losttickpolicy(Object *obj, Visitor *v,
552 const char *name, void *opaque,
553 Error **errp)
554 {
555 Property *prop = opaque;
556 int *ptr = object_field_prop_ptr(obj, prop);
557 int value;
558
559 if (!visit_type_enum(v, name, &value, prop->info->enum_table, errp)) {
560 return;
561 }
562
563 if (value == LOST_TICK_POLICY_SLEW) {
564 MachineState *ms = MACHINE(qdev_get_machine());
565
566 if (!object_dynamic_cast(OBJECT(ms), TYPE_X86_MACHINE)) {
567 error_setg(errp,
568 "the 'slew' policy is only available for x86 machines");
569 return;
570 }
571 }
572
573 *ptr = value;
574 }
575
576 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int));
577
578 const PropertyInfo qdev_prop_losttickpolicy = {
579 .name = "LostTickPolicy",
580 .enum_table = &LostTickPolicy_lookup,
581 .get = qdev_propinfo_get_enum,
582 .set = qdev_propinfo_set_losttickpolicy,
583 .set_default_value = qdev_propinfo_set_default_value_enum,
584 };
585
586 /* --- blocksize --- */
587
set_blocksize(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)588 static void set_blocksize(Object *obj, Visitor *v, const char *name,
589 void *opaque, Error **errp)
590 {
591 DeviceState *dev = DEVICE(obj);
592 Property *prop = opaque;
593 uint32_t *ptr = object_field_prop_ptr(obj, prop);
594 uint64_t value;
595 Error *local_err = NULL;
596
597 if (!visit_type_size(v, name, &value, errp)) {
598 return;
599 }
600 check_block_size(dev->id ? : "", name, value, &local_err);
601 if (local_err) {
602 error_propagate(errp, local_err);
603 return;
604 }
605 *ptr = value;
606 }
607
608 const PropertyInfo qdev_prop_blocksize = {
609 .name = "size",
610 .description = "A power of two between " MIN_BLOCK_SIZE_STR
611 " and " MAX_BLOCK_SIZE_STR,
612 .get = qdev_propinfo_get_size32,
613 .set = set_blocksize,
614 .set_default_value = qdev_propinfo_set_default_value_uint,
615 };
616
617 /* --- Block device error handling policy --- */
618
619 QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError) != sizeof(int));
620
621 const PropertyInfo qdev_prop_blockdev_on_error = {
622 .name = "BlockdevOnError",
623 .description = "Error handling policy, "
624 "report/ignore/enospc/stop/auto",
625 .enum_table = &BlockdevOnError_lookup,
626 .get = qdev_propinfo_get_enum,
627 .set = qdev_propinfo_set_enum,
628 .set_default_value = qdev_propinfo_set_default_value_enum,
629 };
630
631 /* --- BIOS CHS translation */
632
633 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int));
634
635 const PropertyInfo qdev_prop_bios_chs_trans = {
636 .name = "BiosAtaTranslation",
637 .description = "Logical CHS translation algorithm, "
638 "auto/none/lba/large/rechs",
639 .enum_table = &BiosAtaTranslation_lookup,
640 .get = qdev_propinfo_get_enum,
641 .set = qdev_propinfo_set_enum,
642 .set_default_value = qdev_propinfo_set_default_value_enum,
643 };
644
645 /* --- FDC default drive types */
646
647 const PropertyInfo qdev_prop_fdc_drive_type = {
648 .name = "FdcDriveType",
649 .description = "FDC drive type, "
650 "144/288/120/none/auto",
651 .enum_table = &FloppyDriveType_lookup,
652 .get = qdev_propinfo_get_enum,
653 .set = qdev_propinfo_set_enum,
654 .set_default_value = qdev_propinfo_set_default_value_enum,
655 };
656
657 /* --- MultiFDCompression --- */
658
659 const PropertyInfo qdev_prop_multifd_compression = {
660 .name = "MultiFDCompression",
661 .description = "multifd_compression values, "
662 "none/zlib/zstd",
663 .enum_table = &MultiFDCompression_lookup,
664 .get = qdev_propinfo_get_enum,
665 .set = qdev_propinfo_set_enum,
666 .set_default_value = qdev_propinfo_set_default_value_enum,
667 };
668
669 /* --- MigMode --- */
670
671 QEMU_BUILD_BUG_ON(sizeof(MigMode) != sizeof(int));
672
673 const PropertyInfo qdev_prop_mig_mode = {
674 .name = "MigMode",
675 .description = "mig_mode values, "
676 "normal,cpr-reboot",
677 .enum_table = &MigMode_lookup,
678 .get = qdev_propinfo_get_enum,
679 .set = qdev_propinfo_set_enum,
680 .set_default_value = qdev_propinfo_set_default_value_enum,
681 };
682
683 /* --- GranuleMode --- */
684
685 QEMU_BUILD_BUG_ON(sizeof(GranuleMode) != sizeof(int));
686
687 const PropertyInfo qdev_prop_granule_mode = {
688 .name = "GranuleMode",
689 .description = "granule_mode values, "
690 "4k, 8k, 16k, 64k, host",
691 .enum_table = &GranuleMode_lookup,
692 .get = qdev_propinfo_get_enum,
693 .set = qdev_propinfo_set_enum,
694 .set_default_value = qdev_propinfo_set_default_value_enum,
695 };
696
697 const PropertyInfo qdev_prop_zero_page_detection = {
698 .name = "ZeroPageDetection",
699 .description = "zero_page_detection values, "
700 "none,legacy,multifd",
701 .enum_table = &ZeroPageDetection_lookup,
702 .get = qdev_propinfo_get_enum,
703 .set = qdev_propinfo_set_enum,
704 .set_default_value = qdev_propinfo_set_default_value_enum,
705 };
706
707 /* --- Reserved Region --- */
708
709 /*
710 * Accepted syntax:
711 * <low address>:<high address>:<type>
712 * where low/high addresses are uint64_t in hexadecimal
713 * and type is a non-negative decimal integer
714 */
get_reserved_region(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)715 static void get_reserved_region(Object *obj, Visitor *v, const char *name,
716 void *opaque, Error **errp)
717 {
718 Property *prop = opaque;
719 ReservedRegion *rr = object_field_prop_ptr(obj, prop);
720 char buffer[64];
721 char *p = buffer;
722 int rc;
723
724 rc = snprintf(buffer, sizeof(buffer), "0x%"PRIx64":0x%"PRIx64":%u",
725 range_lob(&rr->range), range_upb(&rr->range), rr->type);
726 assert(rc < sizeof(buffer));
727
728 visit_type_str(v, name, &p, errp);
729 }
730
set_reserved_region(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)731 static void set_reserved_region(Object *obj, Visitor *v, const char *name,
732 void *opaque, Error **errp)
733 {
734 Property *prop = opaque;
735 ReservedRegion *rr = object_field_prop_ptr(obj, prop);
736 const char *endptr;
737 uint64_t lob, upb;
738 char *str;
739 int ret;
740
741 if (!visit_type_str(v, name, &str, errp)) {
742 return;
743 }
744
745 ret = qemu_strtou64(str, &endptr, 16, &lob);
746 if (ret) {
747 error_setg(errp, "start address of '%s'"
748 " must be a hexadecimal integer", name);
749 goto out;
750 }
751 if (*endptr != ':') {
752 goto separator_error;
753 }
754
755 ret = qemu_strtou64(endptr + 1, &endptr, 16, &upb);
756 if (ret) {
757 error_setg(errp, "end address of '%s'"
758 " must be a hexadecimal integer", name);
759 goto out;
760 }
761 if (*endptr != ':') {
762 goto separator_error;
763 }
764
765 range_set_bounds(&rr->range, lob, upb);
766
767 ret = qemu_strtoui(endptr + 1, &endptr, 10, &rr->type);
768 if (ret) {
769 error_setg(errp, "type of '%s'"
770 " must be a non-negative decimal integer", name);
771 }
772 goto out;
773
774 separator_error:
775 error_setg(errp, "reserved region fields must be separated with ':'");
776 out:
777 g_free(str);
778 return;
779 }
780
781 const PropertyInfo qdev_prop_reserved_region = {
782 .name = "reserved_region",
783 .description = "Reserved Region, example: 0xFEE00000:0xFEEFFFFF:0",
784 .get = get_reserved_region,
785 .set = set_reserved_region,
786 };
787
788 /* --- pci address --- */
789
790 /*
791 * bus-local address, i.e. "$slot" or "$slot.$fn"
792 */
set_pci_devfn(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)793 static void set_pci_devfn(Object *obj, Visitor *v, const char *name,
794 void *opaque, Error **errp)
795 {
796 Property *prop = opaque;
797 int32_t value, *ptr = object_field_prop_ptr(obj, prop);
798 unsigned int slot, fn, n;
799 char *str;
800
801 if (!visit_type_str(v, name, &str, NULL)) {
802 if (!visit_type_int32(v, name, &value, errp)) {
803 return;
804 }
805 if (value < -1 || value > 255) {
806 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
807 name ? name : "null", "a value between -1 and 255");
808 return;
809 }
810 *ptr = value;
811 return;
812 }
813
814 if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
815 fn = 0;
816 if (sscanf(str, "%x%n", &slot, &n) != 1) {
817 goto invalid;
818 }
819 }
820 if (str[n] != '\0' || fn > 7 || slot > 31) {
821 goto invalid;
822 }
823 *ptr = slot << 3 | fn;
824 g_free(str);
825 return;
826
827 invalid:
828 error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
829 g_free(str);
830 }
831
print_pci_devfn(Object * obj,Property * prop,char * dest,size_t len)832 static int print_pci_devfn(Object *obj, Property *prop, char *dest,
833 size_t len)
834 {
835 int32_t *ptr = object_field_prop_ptr(obj, prop);
836
837 if (*ptr == -1) {
838 return snprintf(dest, len, "<unset>");
839 } else {
840 return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
841 }
842 }
843
844 const PropertyInfo qdev_prop_pci_devfn = {
845 .name = "int32",
846 .description = "Slot and optional function number, example: 06.0 or 06",
847 .print = print_pci_devfn,
848 .get = qdev_propinfo_get_int32,
849 .set = set_pci_devfn,
850 .set_default_value = qdev_propinfo_set_default_value_int,
851 };
852
853 /* --- pci host address --- */
854
get_pci_host_devaddr(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)855 static void get_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
856 void *opaque, Error **errp)
857 {
858 Property *prop = opaque;
859 PCIHostDeviceAddress *addr = object_field_prop_ptr(obj, prop);
860 char buffer[] = "ffff:ff:ff.f";
861 char *p = buffer;
862 int rc = 0;
863
864 /*
865 * Catch "invalid" device reference from vfio-pci and allow the
866 * default buffer representing the non-existent device to be used.
867 */
868 if (~addr->domain || ~addr->bus || ~addr->slot || ~addr->function) {
869 rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%0d",
870 addr->domain, addr->bus, addr->slot, addr->function);
871 assert(rc == sizeof(buffer) - 1);
872 }
873
874 visit_type_str(v, name, &p, errp);
875 }
876
877 /*
878 * Parse [<domain>:]<bus>:<slot>.<func>
879 * if <domain> is not supplied, it's assumed to be 0.
880 */
set_pci_host_devaddr(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)881 static void set_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
882 void *opaque, Error **errp)
883 {
884 Property *prop = opaque;
885 PCIHostDeviceAddress *addr = object_field_prop_ptr(obj, prop);
886 char *str, *p;
887 char *e;
888 unsigned long val;
889 unsigned long dom = 0, bus = 0;
890 unsigned int slot = 0, func = 0;
891
892 if (!visit_type_str(v, name, &str, errp)) {
893 return;
894 }
895
896 p = str;
897 val = strtoul(p, &e, 16);
898 if (e == p || *e != ':') {
899 goto inval;
900 }
901 bus = val;
902
903 p = e + 1;
904 val = strtoul(p, &e, 16);
905 if (e == p) {
906 goto inval;
907 }
908 if (*e == ':') {
909 dom = bus;
910 bus = val;
911 p = e + 1;
912 val = strtoul(p, &e, 16);
913 if (e == p) {
914 goto inval;
915 }
916 }
917 slot = val;
918
919 if (*e != '.') {
920 goto inval;
921 }
922 p = e + 1;
923 val = strtoul(p, &e, 10);
924 if (e == p) {
925 goto inval;
926 }
927 func = val;
928
929 if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) {
930 goto inval;
931 }
932
933 if (*e) {
934 goto inval;
935 }
936
937 addr->domain = dom;
938 addr->bus = bus;
939 addr->slot = slot;
940 addr->function = func;
941
942 g_free(str);
943 return;
944
945 inval:
946 error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
947 g_free(str);
948 }
949
950 const PropertyInfo qdev_prop_pci_host_devaddr = {
951 .name = "str",
952 .description = "Address (bus/device/function) of "
953 "the host device, example: 04:10.0",
954 .get = get_pci_host_devaddr,
955 .set = set_pci_host_devaddr,
956 };
957
958 /* --- OffAutoPCIBAR off/auto/bar0/bar1/bar2/bar3/bar4/bar5 --- */
959
960 const PropertyInfo qdev_prop_off_auto_pcibar = {
961 .name = "OffAutoPCIBAR",
962 .description = "off/auto/bar0/bar1/bar2/bar3/bar4/bar5",
963 .enum_table = &OffAutoPCIBAR_lookup,
964 .get = qdev_propinfo_get_enum,
965 .set = qdev_propinfo_set_enum,
966 .set_default_value = qdev_propinfo_set_default_value_enum,
967 };
968
969 /* --- PCIELinkSpeed 2_5/5/8/16/32/64 -- */
970
get_prop_pcielinkspeed(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)971 static void get_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name,
972 void *opaque, Error **errp)
973 {
974 Property *prop = opaque;
975 PCIExpLinkSpeed *p = object_field_prop_ptr(obj, prop);
976 int speed;
977
978 switch (*p) {
979 case QEMU_PCI_EXP_LNK_2_5GT:
980 speed = PCIE_LINK_SPEED_2_5;
981 break;
982 case QEMU_PCI_EXP_LNK_5GT:
983 speed = PCIE_LINK_SPEED_5;
984 break;
985 case QEMU_PCI_EXP_LNK_8GT:
986 speed = PCIE_LINK_SPEED_8;
987 break;
988 case QEMU_PCI_EXP_LNK_16GT:
989 speed = PCIE_LINK_SPEED_16;
990 break;
991 case QEMU_PCI_EXP_LNK_32GT:
992 speed = PCIE_LINK_SPEED_32;
993 break;
994 case QEMU_PCI_EXP_LNK_64GT:
995 speed = PCIE_LINK_SPEED_64;
996 break;
997 default:
998 /* Unreachable */
999 abort();
1000 }
1001
1002 visit_type_enum(v, name, &speed, prop->info->enum_table, errp);
1003 }
1004
set_prop_pcielinkspeed(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)1005 static void set_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name,
1006 void *opaque, Error **errp)
1007 {
1008 Property *prop = opaque;
1009 PCIExpLinkSpeed *p = object_field_prop_ptr(obj, prop);
1010 int speed;
1011
1012 if (!visit_type_enum(v, name, &speed, prop->info->enum_table,
1013 errp)) {
1014 return;
1015 }
1016
1017 switch (speed) {
1018 case PCIE_LINK_SPEED_2_5:
1019 *p = QEMU_PCI_EXP_LNK_2_5GT;
1020 break;
1021 case PCIE_LINK_SPEED_5:
1022 *p = QEMU_PCI_EXP_LNK_5GT;
1023 break;
1024 case PCIE_LINK_SPEED_8:
1025 *p = QEMU_PCI_EXP_LNK_8GT;
1026 break;
1027 case PCIE_LINK_SPEED_16:
1028 *p = QEMU_PCI_EXP_LNK_16GT;
1029 break;
1030 case PCIE_LINK_SPEED_32:
1031 *p = QEMU_PCI_EXP_LNK_32GT;
1032 break;
1033 case PCIE_LINK_SPEED_64:
1034 *p = QEMU_PCI_EXP_LNK_64GT;
1035 break;
1036 default:
1037 /* Unreachable */
1038 abort();
1039 }
1040 }
1041
1042 const PropertyInfo qdev_prop_pcie_link_speed = {
1043 .name = "PCIELinkSpeed",
1044 .description = "2_5/5/8/16/32/64",
1045 .enum_table = &PCIELinkSpeed_lookup,
1046 .get = get_prop_pcielinkspeed,
1047 .set = set_prop_pcielinkspeed,
1048 .set_default_value = qdev_propinfo_set_default_value_enum,
1049 };
1050
1051 /* --- PCIELinkWidth 1/2/4/8/12/16/32 -- */
1052
get_prop_pcielinkwidth(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)1053 static void get_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name,
1054 void *opaque, Error **errp)
1055 {
1056 Property *prop = opaque;
1057 PCIExpLinkWidth *p = object_field_prop_ptr(obj, prop);
1058 int width;
1059
1060 switch (*p) {
1061 case QEMU_PCI_EXP_LNK_X1:
1062 width = PCIE_LINK_WIDTH_1;
1063 break;
1064 case QEMU_PCI_EXP_LNK_X2:
1065 width = PCIE_LINK_WIDTH_2;
1066 break;
1067 case QEMU_PCI_EXP_LNK_X4:
1068 width = PCIE_LINK_WIDTH_4;
1069 break;
1070 case QEMU_PCI_EXP_LNK_X8:
1071 width = PCIE_LINK_WIDTH_8;
1072 break;
1073 case QEMU_PCI_EXP_LNK_X12:
1074 width = PCIE_LINK_WIDTH_12;
1075 break;
1076 case QEMU_PCI_EXP_LNK_X16:
1077 width = PCIE_LINK_WIDTH_16;
1078 break;
1079 case QEMU_PCI_EXP_LNK_X32:
1080 width = PCIE_LINK_WIDTH_32;
1081 break;
1082 default:
1083 /* Unreachable */
1084 abort();
1085 }
1086
1087 visit_type_enum(v, name, &width, prop->info->enum_table, errp);
1088 }
1089
set_prop_pcielinkwidth(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)1090 static void set_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name,
1091 void *opaque, Error **errp)
1092 {
1093 Property *prop = opaque;
1094 PCIExpLinkWidth *p = object_field_prop_ptr(obj, prop);
1095 int width;
1096
1097 if (!visit_type_enum(v, name, &width, prop->info->enum_table,
1098 errp)) {
1099 return;
1100 }
1101
1102 switch (width) {
1103 case PCIE_LINK_WIDTH_1:
1104 *p = QEMU_PCI_EXP_LNK_X1;
1105 break;
1106 case PCIE_LINK_WIDTH_2:
1107 *p = QEMU_PCI_EXP_LNK_X2;
1108 break;
1109 case PCIE_LINK_WIDTH_4:
1110 *p = QEMU_PCI_EXP_LNK_X4;
1111 break;
1112 case PCIE_LINK_WIDTH_8:
1113 *p = QEMU_PCI_EXP_LNK_X8;
1114 break;
1115 case PCIE_LINK_WIDTH_12:
1116 *p = QEMU_PCI_EXP_LNK_X12;
1117 break;
1118 case PCIE_LINK_WIDTH_16:
1119 *p = QEMU_PCI_EXP_LNK_X16;
1120 break;
1121 case PCIE_LINK_WIDTH_32:
1122 *p = QEMU_PCI_EXP_LNK_X32;
1123 break;
1124 default:
1125 /* Unreachable */
1126 abort();
1127 }
1128 }
1129
1130 const PropertyInfo qdev_prop_pcie_link_width = {
1131 .name = "PCIELinkWidth",
1132 .description = "1/2/4/8/12/16/32",
1133 .enum_table = &PCIELinkWidth_lookup,
1134 .get = get_prop_pcielinkwidth,
1135 .set = set_prop_pcielinkwidth,
1136 .set_default_value = qdev_propinfo_set_default_value_enum,
1137 };
1138
1139 /* --- UUID --- */
1140
get_uuid(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)1141 static void get_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
1142 Error **errp)
1143 {
1144 Property *prop = opaque;
1145 QemuUUID *uuid = object_field_prop_ptr(obj, prop);
1146 char buffer[UUID_STR_LEN];
1147 char *p = buffer;
1148
1149 qemu_uuid_unparse(uuid, buffer);
1150
1151 visit_type_str(v, name, &p, errp);
1152 }
1153
1154 #define UUID_VALUE_AUTO "auto"
1155
set_uuid(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)1156 static void set_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
1157 Error **errp)
1158 {
1159 Property *prop = opaque;
1160 QemuUUID *uuid = object_field_prop_ptr(obj, prop);
1161 char *str;
1162
1163 if (!visit_type_str(v, name, &str, errp)) {
1164 return;
1165 }
1166
1167 if (!strcmp(str, UUID_VALUE_AUTO)) {
1168 qemu_uuid_generate(uuid);
1169 } else if (qemu_uuid_parse(str, uuid) < 0) {
1170 error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
1171 }
1172 g_free(str);
1173 }
1174
set_default_uuid_auto(ObjectProperty * op,const Property * prop)1175 static void set_default_uuid_auto(ObjectProperty *op, const Property *prop)
1176 {
1177 object_property_set_default_str(op, UUID_VALUE_AUTO);
1178 }
1179
1180 const PropertyInfo qdev_prop_uuid = {
1181 .name = "str",
1182 .description = "UUID (aka GUID) or \"" UUID_VALUE_AUTO
1183 "\" for random value (default)",
1184 .get = get_uuid,
1185 .set = set_uuid,
1186 .set_default_value = set_default_uuid_auto,
1187 };
1188
1189 /* --- s390 cpu entitlement policy --- */
1190
1191 QEMU_BUILD_BUG_ON(sizeof(CpuS390Entitlement) != sizeof(int));
1192
1193 const PropertyInfo qdev_prop_cpus390entitlement = {
1194 .name = "CpuS390Entitlement",
1195 .description = "low/medium (default)/high",
1196 .enum_table = &CpuS390Entitlement_lookup,
1197 .get = qdev_propinfo_get_enum,
1198 .set = qdev_propinfo_set_enum,
1199 .set_default_value = qdev_propinfo_set_default_value_enum,
1200 };
1201
1202 /* --- IOThreadVirtQueueMappingList --- */
1203
get_iothread_vq_mapping_list(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)1204 static void get_iothread_vq_mapping_list(Object *obj, Visitor *v,
1205 const char *name, void *opaque, Error **errp)
1206 {
1207 IOThreadVirtQueueMappingList **prop_ptr =
1208 object_field_prop_ptr(obj, opaque);
1209
1210 visit_type_IOThreadVirtQueueMappingList(v, name, prop_ptr, errp);
1211 }
1212
set_iothread_vq_mapping_list(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)1213 static void set_iothread_vq_mapping_list(Object *obj, Visitor *v,
1214 const char *name, void *opaque, Error **errp)
1215 {
1216 IOThreadVirtQueueMappingList **prop_ptr =
1217 object_field_prop_ptr(obj, opaque);
1218 IOThreadVirtQueueMappingList *list;
1219
1220 if (!visit_type_IOThreadVirtQueueMappingList(v, name, &list, errp)) {
1221 return;
1222 }
1223
1224 qapi_free_IOThreadVirtQueueMappingList(*prop_ptr);
1225 *prop_ptr = list;
1226 }
1227
release_iothread_vq_mapping_list(Object * obj,const char * name,void * opaque)1228 static void release_iothread_vq_mapping_list(Object *obj,
1229 const char *name, void *opaque)
1230 {
1231 IOThreadVirtQueueMappingList **prop_ptr =
1232 object_field_prop_ptr(obj, opaque);
1233
1234 qapi_free_IOThreadVirtQueueMappingList(*prop_ptr);
1235 *prop_ptr = NULL;
1236 }
1237
1238 const PropertyInfo qdev_prop_iothread_vq_mapping_list = {
1239 .name = "IOThreadVirtQueueMappingList",
1240 .description = "IOThread virtqueue mapping list [{\"iothread\":\"<id>\", "
1241 "\"vqs\":[1,2,3,...]},...]",
1242 .get = get_iothread_vq_mapping_list,
1243 .set = set_iothread_vq_mapping_list,
1244 .release = release_iothread_vq_mapping_list,
1245 };
1246