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