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