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