hw/core/qdev-properties-system.c

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