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 
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 
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 
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 
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 
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 
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 
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 
242 static void set_chr(Object *obj, Visitor *v, const char *name, void *opaque,
243                     Error **errp)
244 {
245     Property *prop = opaque;
246     CharBackend *be = object_field_prop_ptr(obj, prop);
247     Chardev *s;
248     char *str;
249 
250     if (!visit_type_str(v, name, &str, errp)) {
251         return;
252     }
253 
254     /*
255      * TODO Should this really be an error?  If no, the old value
256      * needs to be released before we store the new one.
257      */
258     if (!check_prop_still_unset(obj, name, be->chr, str, false, errp)) {
259         return;
260     }
261 
262     if (!*str) {
263         g_free(str);
264         be->chr = NULL;
265         return;
266     }
267 
268     s = qemu_chr_find(str);
269     if (s == NULL) {
270         error_setg(errp, "Property '%s.%s' can't find value '%s'",
271                    object_get_typename(obj), name, str);
272     } else if (!qemu_chr_fe_init(be, s, errp)) {
273         error_prepend(errp, "Property '%s.%s' can't take value '%s': ",
274                       object_get_typename(obj), name, str);
275     }
276     g_free(str);
277 }
278 
279 static void release_chr(Object *obj, const char *name, void *opaque)
280 {
281     Property *prop = opaque;
282     CharBackend *be = object_field_prop_ptr(obj, prop);
283 
284     qemu_chr_fe_deinit(be, false);
285 }
286 
287 const PropertyInfo qdev_prop_chr = {
288     .name  = "str",
289     .description = "ID of a chardev to use as a backend",
290     .get   = get_chr,
291     .set   = set_chr,
292     .release = release_chr,
293 };
294 
295 /* --- mac address --- */
296 
297 /*
298  * accepted syntax versions:
299  *   01:02:03:04:05:06
300  *   01-02-03-04-05-06
301  */
302 static void get_mac(Object *obj, Visitor *v, const char *name, void *opaque,
303                     Error **errp)
304 {
305     Property *prop = opaque;
306     MACAddr *mac = object_field_prop_ptr(obj, prop);
307     char buffer[2 * 6 + 5 + 1];
308     char *p = buffer;
309 
310     snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
311              mac->a[0], mac->a[1], mac->a[2],
312              mac->a[3], mac->a[4], mac->a[5]);
313 
314     visit_type_str(v, name, &p, errp);
315 }
316 
317 static void set_mac(Object *obj, Visitor *v, const char *name, void *opaque,
318                     Error **errp)
319 {
320     Property *prop = opaque;
321     MACAddr *mac = object_field_prop_ptr(obj, prop);
322     int i, pos;
323     char *str;
324     const char *p;
325 
326     if (!visit_type_str(v, name, &str, errp)) {
327         return;
328     }
329 
330     for (i = 0, pos = 0; i < 6; i++, pos += 3) {
331         long val;
332 
333         if (!qemu_isxdigit(str[pos])) {
334             goto inval;
335         }
336         if (!qemu_isxdigit(str[pos + 1])) {
337             goto inval;
338         }
339         if (i == 5) {
340             if (str[pos + 2] != '\0') {
341                 goto inval;
342             }
343         } else {
344             if (str[pos + 2] != ':' && str[pos + 2] != '-') {
345                 goto inval;
346             }
347         }
348         if (qemu_strtol(str + pos, &p, 16, &val) < 0 || val > 0xff) {
349             goto inval;
350         }
351         mac->a[i] = val;
352     }
353     g_free(str);
354     return;
355 
356 inval:
357     error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
358     g_free(str);
359 }
360 
361 const PropertyInfo qdev_prop_macaddr = {
362     .name  = "str",
363     .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
364     .get   = get_mac,
365     .set   = set_mac,
366 };
367 
368 void qdev_prop_set_macaddr(DeviceState *dev, const char *name,
369                            const uint8_t *value)
370 {
371     char str[2 * 6 + 5 + 1];
372     snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
373              value[0], value[1], value[2], value[3], value[4], value[5]);
374 
375     object_property_set_str(OBJECT(dev), name, str, &error_abort);
376 }
377 
378 /* --- netdev device --- */
379 static void get_netdev(Object *obj, Visitor *v, const char *name,
380                        void *opaque, Error **errp)
381 {
382     Property *prop = opaque;
383     NICPeers *peers_ptr = object_field_prop_ptr(obj, prop);
384     char *p = g_strdup(peers_ptr->ncs[0] ? peers_ptr->ncs[0]->name : "");
385 
386     visit_type_str(v, name, &p, errp);
387     g_free(p);
388 }
389 
390 static void set_netdev(Object *obj, Visitor *v, const char *name,
391                        void *opaque, Error **errp)
392 {
393     Property *prop = opaque;
394     NICPeers *peers_ptr = object_field_prop_ptr(obj, prop);
395     NetClientState **ncs = peers_ptr->ncs;
396     NetClientState *peers[MAX_QUEUE_NUM];
397     int queues, err = 0, i = 0;
398     char *str;
399 
400     if (!visit_type_str(v, name, &str, errp)) {
401         return;
402     }
403 
404     queues = qemu_find_net_clients_except(str, peers,
405                                           NET_CLIENT_DRIVER_NIC,
406                                           MAX_QUEUE_NUM);
407     if (queues == 0) {
408         err = -ENOENT;
409         goto out;
410     }
411 
412     if (queues > MAX_QUEUE_NUM) {
413         error_setg(errp, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)",
414                    str, queues, MAX_QUEUE_NUM);
415         goto out;
416     }
417 
418     for (i = 0; i < queues; i++) {
419         if (peers[i]->peer) {
420             err = -EEXIST;
421             goto out;
422         }
423 
424         /*
425          * TODO Should this really be an error?  If no, the old value
426          * needs to be released before we store the new one.
427          */
428         if (!check_prop_still_unset(obj, name, ncs[i], str, false, errp)) {
429             goto out;
430         }
431 
432         if (peers[i]->info->check_peer_type) {
433             if (!peers[i]->info->check_peer_type(peers[i], obj->class, errp)) {
434                 goto out;
435             }
436         }
437 
438         ncs[i] = peers[i];
439         ncs[i]->queue_index = i;
440     }
441 
442     peers_ptr->queues = queues;
443 
444 out:
445     error_set_from_qdev_prop_error(errp, err, obj, prop->name, str);
446     g_free(str);
447 }
448 
449 const PropertyInfo qdev_prop_netdev = {
450     .name  = "str",
451     .description = "ID of a netdev to use as a backend",
452     .get   = get_netdev,
453     .set   = set_netdev,
454 };
455 
456 
457 /* --- audiodev --- */
458 static void get_audiodev(Object *obj, Visitor *v, const char* name,
459                          void *opaque, Error **errp)
460 {
461     Property *prop = opaque;
462     QEMUSoundCard *card = object_field_prop_ptr(obj, prop);
463     char *p = g_strdup(audio_get_id(card));
464 
465     visit_type_str(v, name, &p, errp);
466     g_free(p);
467 }
468 
469 static void set_audiodev(Object *obj, Visitor *v, const char* name,
470                          void *opaque, Error **errp)
471 {
472     Property *prop = opaque;
473     QEMUSoundCard *card = object_field_prop_ptr(obj, prop);
474     AudioState *state;
475     g_autofree char *str = NULL;
476 
477     if (!visit_type_str(v, name, &str, errp)) {
478         return;
479     }
480 
481     state = audio_state_by_name(str, errp);
482     if (state) {
483         card->state = state;
484     }
485 }
486 
487 const PropertyInfo qdev_prop_audiodev = {
488     .name = "str",
489     .description = "ID of an audiodev to use as a backend",
490     /* release done on shutdown */
491     .get = get_audiodev,
492     .set = set_audiodev,
493 };
494 
495 bool qdev_prop_set_drive_err(DeviceState *dev, const char *name,
496                              BlockBackend *value, Error **errp)
497 {
498     const char *ref = "";
499 
500     if (value) {
501         ref = blk_name(value);
502         if (!*ref) {
503             const BlockDriverState *bs = blk_bs(value);
504             if (bs) {
505                 ref = bdrv_get_node_name(bs);
506             }
507         }
508     }
509 
510     return object_property_set_str(OBJECT(dev), name, ref, errp);
511 }
512 
513 void qdev_prop_set_drive(DeviceState *dev, const char *name,
514                          BlockBackend *value)
515 {
516     qdev_prop_set_drive_err(dev, name, value, &error_abort);
517 }
518 
519 void qdev_prop_set_chr(DeviceState *dev, const char *name,
520                        Chardev *value)
521 {
522     assert(!value || value->label);
523     object_property_set_str(OBJECT(dev), name, value ? value->label : "",
524                             &error_abort);
525 }
526 
527 void qdev_prop_set_netdev(DeviceState *dev, const char *name,
528                           NetClientState *value)
529 {
530     assert(!value || value->name);
531     object_property_set_str(OBJECT(dev), name, value ? value->name : "",
532                             &error_abort);
533 }
534 
535 void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
536 {
537     qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
538     if (nd->netdev) {
539         qdev_prop_set_netdev(dev, "netdev", nd->netdev);
540     }
541     if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
542         object_property_find(OBJECT(dev), "vectors")) {
543         qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
544     }
545     nd->instantiated = 1;
546 }
547 
548 /* --- lost tick policy --- */
549 
550 static void qdev_propinfo_set_losttickpolicy(Object *obj, Visitor *v,
551                                              const char *name, void *opaque,
552                                              Error **errp)
553 {
554     Property *prop = opaque;
555     int *ptr = object_field_prop_ptr(obj, prop);
556     int value;
557 
558     if (!visit_type_enum(v, name, &value, prop->info->enum_table, errp)) {
559         return;
560     }
561 
562     if (value == LOST_TICK_POLICY_SLEW) {
563         MachineState *ms = MACHINE(qdev_get_machine());
564 
565         if (!object_dynamic_cast(OBJECT(ms), TYPE_X86_MACHINE)) {
566             error_setg(errp,
567                        "the 'slew' policy is only available for x86 machines");
568             return;
569         }
570     }
571 
572     *ptr = value;
573 }
574 
575 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int));
576 
577 const PropertyInfo qdev_prop_losttickpolicy = {
578     .name  = "LostTickPolicy",
579     .enum_table  = &LostTickPolicy_lookup,
580     .get   = qdev_propinfo_get_enum,
581     .set   = qdev_propinfo_set_losttickpolicy,
582     .set_default_value = qdev_propinfo_set_default_value_enum,
583 };
584 
585 /* --- blocksize --- */
586 
587 static void set_blocksize(Object *obj, Visitor *v, const char *name,
588                           void *opaque, Error **errp)
589 {
590     DeviceState *dev = DEVICE(obj);
591     Property *prop = opaque;
592     uint32_t *ptr = object_field_prop_ptr(obj, prop);
593     uint64_t value;
594     Error *local_err = NULL;
595 
596     if (!visit_type_size(v, name, &value, errp)) {
597         return;
598     }
599     check_block_size(dev->id ? : "", name, value, &local_err);
600     if (local_err) {
601         error_propagate(errp, local_err);
602         return;
603     }
604     *ptr = value;
605 }
606 
607 const PropertyInfo qdev_prop_blocksize = {
608     .name  = "size",
609     .description = "A power of two between " MIN_BLOCK_SIZE_STR
610                    " and " MAX_BLOCK_SIZE_STR,
611     .get   = qdev_propinfo_get_size32,
612     .set   = set_blocksize,
613     .set_default_value = qdev_propinfo_set_default_value_uint,
614 };
615 
616 /* --- Block device error handling policy --- */
617 
618 QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError) != sizeof(int));
619 
620 const PropertyInfo qdev_prop_blockdev_on_error = {
621     .name = "BlockdevOnError",
622     .description = "Error handling policy, "
623                    "report/ignore/enospc/stop/auto",
624     .enum_table = &BlockdevOnError_lookup,
625     .get = qdev_propinfo_get_enum,
626     .set = qdev_propinfo_set_enum,
627     .set_default_value = qdev_propinfo_set_default_value_enum,
628 };
629 
630 /* --- BIOS CHS translation */
631 
632 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int));
633 
634 const PropertyInfo qdev_prop_bios_chs_trans = {
635     .name = "BiosAtaTranslation",
636     .description = "Logical CHS translation algorithm, "
637                    "auto/none/lba/large/rechs",
638     .enum_table = &BiosAtaTranslation_lookup,
639     .get = qdev_propinfo_get_enum,
640     .set = qdev_propinfo_set_enum,
641     .set_default_value = qdev_propinfo_set_default_value_enum,
642 };
643 
644 /* --- FDC default drive types */
645 
646 const PropertyInfo qdev_prop_fdc_drive_type = {
647     .name = "FdcDriveType",
648     .description = "FDC drive type, "
649                    "144/288/120/none/auto",
650     .enum_table = &FloppyDriveType_lookup,
651     .get = qdev_propinfo_get_enum,
652     .set = qdev_propinfo_set_enum,
653     .set_default_value = qdev_propinfo_set_default_value_enum,
654 };
655 
656 /* --- MultiFDCompression --- */
657 
658 const PropertyInfo qdev_prop_multifd_compression = {
659     .name = "MultiFDCompression",
660     .description = "multifd_compression values, "
661                    "none/zlib/zstd",
662     .enum_table = &MultiFDCompression_lookup,
663     .get = qdev_propinfo_get_enum,
664     .set = qdev_propinfo_set_enum,
665     .set_default_value = qdev_propinfo_set_default_value_enum,
666 };
667 
668 /* --- MigMode --- */
669 
670 QEMU_BUILD_BUG_ON(sizeof(MigMode) != sizeof(int));
671 
672 const PropertyInfo qdev_prop_mig_mode = {
673     .name = "MigMode",
674     .description = "mig_mode values, "
675                    "normal,cpr-reboot",
676     .enum_table = &MigMode_lookup,
677     .get = qdev_propinfo_get_enum,
678     .set = qdev_propinfo_set_enum,
679     .set_default_value = qdev_propinfo_set_default_value_enum,
680 };
681 
682 /* --- Reserved Region --- */
683 
684 /*
685  * Accepted syntax:
686  *   <low address>:<high address>:<type>
687  *   where low/high addresses are uint64_t in hexadecimal
688  *   and type is a non-negative decimal integer
689  */
690 static void get_reserved_region(Object *obj, Visitor *v, const char *name,
691                                 void *opaque, Error **errp)
692 {
693     Property *prop = opaque;
694     ReservedRegion *rr = object_field_prop_ptr(obj, prop);
695     char buffer[64];
696     char *p = buffer;
697     int rc;
698 
699     rc = snprintf(buffer, sizeof(buffer), "0x%"PRIx64":0x%"PRIx64":%u",
700                   range_lob(&rr->range), range_upb(&rr->range), rr->type);
701     assert(rc < sizeof(buffer));
702 
703     visit_type_str(v, name, &p, errp);
704 }
705 
706 static void set_reserved_region(Object *obj, Visitor *v, const char *name,
707                                 void *opaque, Error **errp)
708 {
709     Property *prop = opaque;
710     ReservedRegion *rr = object_field_prop_ptr(obj, prop);
711     const char *endptr;
712     uint64_t lob, upb;
713     char *str;
714     int ret;
715 
716     if (!visit_type_str(v, name, &str, errp)) {
717         return;
718     }
719 
720     ret = qemu_strtou64(str, &endptr, 16, &lob);
721     if (ret) {
722         error_setg(errp, "start address of '%s'"
723                    " must be a hexadecimal integer", name);
724         goto out;
725     }
726     if (*endptr != ':') {
727         goto separator_error;
728     }
729 
730     ret = qemu_strtou64(endptr + 1, &endptr, 16, &upb);
731     if (ret) {
732         error_setg(errp, "end address of '%s'"
733                    " must be a hexadecimal integer", name);
734         goto out;
735     }
736     if (*endptr != ':') {
737         goto separator_error;
738     }
739 
740     range_set_bounds(&rr->range, lob, upb);
741 
742     ret = qemu_strtoui(endptr + 1, &endptr, 10, &rr->type);
743     if (ret) {
744         error_setg(errp, "type of '%s'"
745                    " must be a non-negative decimal integer", name);
746     }
747     goto out;
748 
749 separator_error:
750     error_setg(errp, "reserved region fields must be separated with ':'");
751 out:
752     g_free(str);
753     return;
754 }
755 
756 const PropertyInfo qdev_prop_reserved_region = {
757     .name  = "reserved_region",
758     .description = "Reserved Region, example: 0xFEE00000:0xFEEFFFFF:0",
759     .get   = get_reserved_region,
760     .set   = set_reserved_region,
761 };
762 
763 /* --- pci address --- */
764 
765 /*
766  * bus-local address, i.e. "$slot" or "$slot.$fn"
767  */
768 static void set_pci_devfn(Object *obj, Visitor *v, const char *name,
769                           void *opaque, Error **errp)
770 {
771     Property *prop = opaque;
772     int32_t value, *ptr = object_field_prop_ptr(obj, prop);
773     unsigned int slot, fn, n;
774     char *str;
775 
776     if (!visit_type_str(v, name, &str, NULL)) {
777         if (!visit_type_int32(v, name, &value, errp)) {
778             return;
779         }
780         if (value < -1 || value > 255) {
781             error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
782                        name ? name : "null", "a value between -1 and 255");
783             return;
784         }
785         *ptr = value;
786         return;
787     }
788 
789     if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
790         fn = 0;
791         if (sscanf(str, "%x%n", &slot, &n) != 1) {
792             goto invalid;
793         }
794     }
795     if (str[n] != '\0' || fn > 7 || slot > 31) {
796         goto invalid;
797     }
798     *ptr = slot << 3 | fn;
799     g_free(str);
800     return;
801 
802 invalid:
803     error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
804     g_free(str);
805 }
806 
807 static int print_pci_devfn(Object *obj, Property *prop, char *dest,
808                            size_t len)
809 {
810     int32_t *ptr = object_field_prop_ptr(obj, prop);
811 
812     if (*ptr == -1) {
813         return snprintf(dest, len, "<unset>");
814     } else {
815         return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
816     }
817 }
818 
819 const PropertyInfo qdev_prop_pci_devfn = {
820     .name  = "int32",
821     .description = "Slot and optional function number, example: 06.0 or 06",
822     .print = print_pci_devfn,
823     .get   = qdev_propinfo_get_int32,
824     .set   = set_pci_devfn,
825     .set_default_value = qdev_propinfo_set_default_value_int,
826 };
827 
828 /* --- pci host address --- */
829 
830 static void get_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
831                                  void *opaque, Error **errp)
832 {
833     Property *prop = opaque;
834     PCIHostDeviceAddress *addr = object_field_prop_ptr(obj, prop);
835     char buffer[] = "ffff:ff:ff.f";
836     char *p = buffer;
837     int rc = 0;
838 
839     /*
840      * Catch "invalid" device reference from vfio-pci and allow the
841      * default buffer representing the non-existent device to be used.
842      */
843     if (~addr->domain || ~addr->bus || ~addr->slot || ~addr->function) {
844         rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%0d",
845                       addr->domain, addr->bus, addr->slot, addr->function);
846         assert(rc == sizeof(buffer) - 1);
847     }
848 
849     visit_type_str(v, name, &p, errp);
850 }
851 
852 /*
853  * Parse [<domain>:]<bus>:<slot>.<func>
854  *   if <domain> is not supplied, it's assumed to be 0.
855  */
856 static void set_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
857                                  void *opaque, Error **errp)
858 {
859     Property *prop = opaque;
860     PCIHostDeviceAddress *addr = object_field_prop_ptr(obj, prop);
861     char *str, *p;
862     char *e;
863     unsigned long val;
864     unsigned long dom = 0, bus = 0;
865     unsigned int slot = 0, func = 0;
866 
867     if (!visit_type_str(v, name, &str, errp)) {
868         return;
869     }
870 
871     p = str;
872     val = strtoul(p, &e, 16);
873     if (e == p || *e != ':') {
874         goto inval;
875     }
876     bus = val;
877 
878     p = e + 1;
879     val = strtoul(p, &e, 16);
880     if (e == p) {
881         goto inval;
882     }
883     if (*e == ':') {
884         dom = bus;
885         bus = val;
886         p = e + 1;
887         val = strtoul(p, &e, 16);
888         if (e == p) {
889             goto inval;
890         }
891     }
892     slot = val;
893 
894     if (*e != '.') {
895         goto inval;
896     }
897     p = e + 1;
898     val = strtoul(p, &e, 10);
899     if (e == p) {
900         goto inval;
901     }
902     func = val;
903 
904     if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) {
905         goto inval;
906     }
907 
908     if (*e) {
909         goto inval;
910     }
911 
912     addr->domain = dom;
913     addr->bus = bus;
914     addr->slot = slot;
915     addr->function = func;
916 
917     g_free(str);
918     return;
919 
920 inval:
921     error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
922     g_free(str);
923 }
924 
925 const PropertyInfo qdev_prop_pci_host_devaddr = {
926     .name = "str",
927     .description = "Address (bus/device/function) of "
928                    "the host device, example: 04:10.0",
929     .get = get_pci_host_devaddr,
930     .set = set_pci_host_devaddr,
931 };
932 
933 /* --- OffAutoPCIBAR off/auto/bar0/bar1/bar2/bar3/bar4/bar5 --- */
934 
935 const PropertyInfo qdev_prop_off_auto_pcibar = {
936     .name = "OffAutoPCIBAR",
937     .description = "off/auto/bar0/bar1/bar2/bar3/bar4/bar5",
938     .enum_table = &OffAutoPCIBAR_lookup,
939     .get = qdev_propinfo_get_enum,
940     .set = qdev_propinfo_set_enum,
941     .set_default_value = qdev_propinfo_set_default_value_enum,
942 };
943 
944 /* --- PCIELinkSpeed 2_5/5/8/16 -- */
945 
946 static void get_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name,
947                                    void *opaque, Error **errp)
948 {
949     Property *prop = opaque;
950     PCIExpLinkSpeed *p = object_field_prop_ptr(obj, prop);
951     int speed;
952 
953     switch (*p) {
954     case QEMU_PCI_EXP_LNK_2_5GT:
955         speed = PCIE_LINK_SPEED_2_5;
956         break;
957     case QEMU_PCI_EXP_LNK_5GT:
958         speed = PCIE_LINK_SPEED_5;
959         break;
960     case QEMU_PCI_EXP_LNK_8GT:
961         speed = PCIE_LINK_SPEED_8;
962         break;
963     case QEMU_PCI_EXP_LNK_16GT:
964         speed = PCIE_LINK_SPEED_16;
965         break;
966     default:
967         /* Unreachable */
968         abort();
969     }
970 
971     visit_type_enum(v, name, &speed, prop->info->enum_table, errp);
972 }
973 
974 static void set_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name,
975                                    void *opaque, Error **errp)
976 {
977     Property *prop = opaque;
978     PCIExpLinkSpeed *p = object_field_prop_ptr(obj, prop);
979     int speed;
980 
981     if (!visit_type_enum(v, name, &speed, prop->info->enum_table,
982                          errp)) {
983         return;
984     }
985 
986     switch (speed) {
987     case PCIE_LINK_SPEED_2_5:
988         *p = QEMU_PCI_EXP_LNK_2_5GT;
989         break;
990     case PCIE_LINK_SPEED_5:
991         *p = QEMU_PCI_EXP_LNK_5GT;
992         break;
993     case PCIE_LINK_SPEED_8:
994         *p = QEMU_PCI_EXP_LNK_8GT;
995         break;
996     case PCIE_LINK_SPEED_16:
997         *p = QEMU_PCI_EXP_LNK_16GT;
998         break;
999     default:
1000         /* Unreachable */
1001         abort();
1002     }
1003 }
1004 
1005 const PropertyInfo qdev_prop_pcie_link_speed = {
1006     .name = "PCIELinkSpeed",
1007     .description = "2_5/5/8/16",
1008     .enum_table = &PCIELinkSpeed_lookup,
1009     .get = get_prop_pcielinkspeed,
1010     .set = set_prop_pcielinkspeed,
1011     .set_default_value = qdev_propinfo_set_default_value_enum,
1012 };
1013 
1014 /* --- PCIELinkWidth 1/2/4/8/12/16/32 -- */
1015 
1016 static void get_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name,
1017                                    void *opaque, Error **errp)
1018 {
1019     Property *prop = opaque;
1020     PCIExpLinkWidth *p = object_field_prop_ptr(obj, prop);
1021     int width;
1022 
1023     switch (*p) {
1024     case QEMU_PCI_EXP_LNK_X1:
1025         width = PCIE_LINK_WIDTH_1;
1026         break;
1027     case QEMU_PCI_EXP_LNK_X2:
1028         width = PCIE_LINK_WIDTH_2;
1029         break;
1030     case QEMU_PCI_EXP_LNK_X4:
1031         width = PCIE_LINK_WIDTH_4;
1032         break;
1033     case QEMU_PCI_EXP_LNK_X8:
1034         width = PCIE_LINK_WIDTH_8;
1035         break;
1036     case QEMU_PCI_EXP_LNK_X12:
1037         width = PCIE_LINK_WIDTH_12;
1038         break;
1039     case QEMU_PCI_EXP_LNK_X16:
1040         width = PCIE_LINK_WIDTH_16;
1041         break;
1042     case QEMU_PCI_EXP_LNK_X32:
1043         width = PCIE_LINK_WIDTH_32;
1044         break;
1045     default:
1046         /* Unreachable */
1047         abort();
1048     }
1049 
1050     visit_type_enum(v, name, &width, prop->info->enum_table, errp);
1051 }
1052 
1053 static void set_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     if (!visit_type_enum(v, name, &width, prop->info->enum_table,
1061                          errp)) {
1062         return;
1063     }
1064 
1065     switch (width) {
1066     case PCIE_LINK_WIDTH_1:
1067         *p = QEMU_PCI_EXP_LNK_X1;
1068         break;
1069     case PCIE_LINK_WIDTH_2:
1070         *p = QEMU_PCI_EXP_LNK_X2;
1071         break;
1072     case PCIE_LINK_WIDTH_4:
1073         *p = QEMU_PCI_EXP_LNK_X4;
1074         break;
1075     case PCIE_LINK_WIDTH_8:
1076         *p = QEMU_PCI_EXP_LNK_X8;
1077         break;
1078     case PCIE_LINK_WIDTH_12:
1079         *p = QEMU_PCI_EXP_LNK_X12;
1080         break;
1081     case PCIE_LINK_WIDTH_16:
1082         *p = QEMU_PCI_EXP_LNK_X16;
1083         break;
1084     case PCIE_LINK_WIDTH_32:
1085         *p = QEMU_PCI_EXP_LNK_X32;
1086         break;
1087     default:
1088         /* Unreachable */
1089         abort();
1090     }
1091 }
1092 
1093 const PropertyInfo qdev_prop_pcie_link_width = {
1094     .name = "PCIELinkWidth",
1095     .description = "1/2/4/8/12/16/32",
1096     .enum_table = &PCIELinkWidth_lookup,
1097     .get = get_prop_pcielinkwidth,
1098     .set = set_prop_pcielinkwidth,
1099     .set_default_value = qdev_propinfo_set_default_value_enum,
1100 };
1101 
1102 /* --- UUID --- */
1103 
1104 static void get_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
1105                      Error **errp)
1106 {
1107     Property *prop = opaque;
1108     QemuUUID *uuid = object_field_prop_ptr(obj, prop);
1109     char buffer[UUID_STR_LEN];
1110     char *p = buffer;
1111 
1112     qemu_uuid_unparse(uuid, buffer);
1113 
1114     visit_type_str(v, name, &p, errp);
1115 }
1116 
1117 #define UUID_VALUE_AUTO        "auto"
1118 
1119 static void set_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
1120                     Error **errp)
1121 {
1122     Property *prop = opaque;
1123     QemuUUID *uuid = object_field_prop_ptr(obj, prop);
1124     char *str;
1125 
1126     if (!visit_type_str(v, name, &str, errp)) {
1127         return;
1128     }
1129 
1130     if (!strcmp(str, UUID_VALUE_AUTO)) {
1131         qemu_uuid_generate(uuid);
1132     } else if (qemu_uuid_parse(str, uuid) < 0) {
1133         error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
1134     }
1135     g_free(str);
1136 }
1137 
1138 static void set_default_uuid_auto(ObjectProperty *op, const Property *prop)
1139 {
1140     object_property_set_default_str(op, UUID_VALUE_AUTO);
1141 }
1142 
1143 const PropertyInfo qdev_prop_uuid = {
1144     .name  = "str",
1145     .description = "UUID (aka GUID) or \"" UUID_VALUE_AUTO
1146         "\" for random value (default)",
1147     .get   = get_uuid,
1148     .set   = set_uuid,
1149     .set_default_value = set_default_uuid_auto,
1150 };
1151 
1152 /* --- s390 cpu entitlement policy --- */
1153 
1154 QEMU_BUILD_BUG_ON(sizeof(CpuS390Entitlement) != sizeof(int));
1155 
1156 const PropertyInfo qdev_prop_cpus390entitlement = {
1157     .name  = "CpuS390Entitlement",
1158     .description = "low/medium (default)/high",
1159     .enum_table  = &CpuS390Entitlement_lookup,
1160     .get   = qdev_propinfo_get_enum,
1161     .set   = qdev_propinfo_set_enum,
1162     .set_default_value = qdev_propinfo_set_default_value_enum,
1163 };
1164 
1165 /* --- IOThreadVirtQueueMappingList --- */
1166 
1167 static void get_iothread_vq_mapping_list(Object *obj, Visitor *v,
1168         const char *name, void *opaque, Error **errp)
1169 {
1170     IOThreadVirtQueueMappingList **prop_ptr =
1171         object_field_prop_ptr(obj, opaque);
1172 
1173     visit_type_IOThreadVirtQueueMappingList(v, name, prop_ptr, errp);
1174 }
1175 
1176 static void set_iothread_vq_mapping_list(Object *obj, Visitor *v,
1177         const char *name, void *opaque, Error **errp)
1178 {
1179     IOThreadVirtQueueMappingList **prop_ptr =
1180         object_field_prop_ptr(obj, opaque);
1181     IOThreadVirtQueueMappingList *list;
1182 
1183     if (!visit_type_IOThreadVirtQueueMappingList(v, name, &list, errp)) {
1184         return;
1185     }
1186 
1187     qapi_free_IOThreadVirtQueueMappingList(*prop_ptr);
1188     *prop_ptr = list;
1189 }
1190 
1191 static void release_iothread_vq_mapping_list(Object *obj,
1192         const char *name, void *opaque)
1193 {
1194     IOThreadVirtQueueMappingList **prop_ptr =
1195         object_field_prop_ptr(obj, opaque);
1196 
1197     qapi_free_IOThreadVirtQueueMappingList(*prop_ptr);
1198     *prop_ptr = NULL;
1199 }
1200 
1201 const PropertyInfo qdev_prop_iothread_vq_mapping_list = {
1202     .name = "IOThreadVirtQueueMappingList",
1203     .description = "IOThread virtqueue mapping list [{\"iothread\":\"<id>\", "
1204                    "\"vqs\":[1,2,3,...]},...]",
1205     .get = get_iothread_vq_mapping_list,
1206     .set = set_iothread_vq_mapping_list,
1207     .release = release_iothread_vq_mapping_list,
1208 };
1209