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