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