1 #include "qemu/osdep.h" 2 #include "net/net.h" 3 #include "hw/qdev-properties.h" 4 #include "qapi/error.h" 5 #include "hw/pci/pci.h" 6 #include "qapi/qapi-types-block.h" 7 #include "qapi/qapi-types-misc.h" 8 #include "qapi/qmp/qerror.h" 9 #include "qemu/ctype.h" 10 #include "qemu/error-report.h" 11 #include "qapi/qapi-types-migration.h" 12 #include "hw/block/block.h" 13 #include "net/hub.h" 14 #include "qapi/visitor.h" 15 #include "chardev/char.h" 16 #include "qemu/uuid.h" 17 18 void qdev_prop_set_after_realize(DeviceState *dev, const char *name, 19 Error **errp) 20 { 21 if (dev->id) { 22 error_setg(errp, "Attempt to set property '%s' on device '%s' " 23 "(type '%s') after it was realized", name, dev->id, 24 object_get_typename(OBJECT(dev))); 25 } else { 26 error_setg(errp, "Attempt to set property '%s' on anonymous device " 27 "(type '%s') after it was realized", name, 28 object_get_typename(OBJECT(dev))); 29 } 30 } 31 32 void qdev_prop_allow_set_link_before_realize(const Object *obj, 33 const char *name, 34 Object *val, Error **errp) 35 { 36 DeviceState *dev = DEVICE(obj); 37 38 if (dev->realized) { 39 error_setg(errp, "Attempt to set link property '%s' on device '%s' " 40 "(type '%s') after it was realized", 41 name, dev->id, object_get_typename(obj)); 42 } 43 } 44 45 void *qdev_get_prop_ptr(DeviceState *dev, Property *prop) 46 { 47 void *ptr = dev; 48 ptr += prop->offset; 49 return ptr; 50 } 51 52 static void get_enum(Object *obj, Visitor *v, const char *name, void *opaque, 53 Error **errp) 54 { 55 DeviceState *dev = DEVICE(obj); 56 Property *prop = opaque; 57 int *ptr = qdev_get_prop_ptr(dev, prop); 58 59 visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp); 60 } 61 62 static void set_enum(Object *obj, Visitor *v, const char *name, void *opaque, 63 Error **errp) 64 { 65 DeviceState *dev = DEVICE(obj); 66 Property *prop = opaque; 67 int *ptr = qdev_get_prop_ptr(dev, prop); 68 69 if (dev->realized) { 70 qdev_prop_set_after_realize(dev, name, errp); 71 return; 72 } 73 74 visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp); 75 } 76 77 static void set_default_value_enum(ObjectProperty *op, const Property *prop) 78 { 79 object_property_set_default_str(op, 80 qapi_enum_lookup(prop->info->enum_table, prop->defval.i)); 81 } 82 83 /* Bit */ 84 85 static uint32_t qdev_get_prop_mask(Property *prop) 86 { 87 assert(prop->info == &qdev_prop_bit); 88 return 0x1 << prop->bitnr; 89 } 90 91 static void bit_prop_set(DeviceState *dev, Property *props, bool val) 92 { 93 uint32_t *p = qdev_get_prop_ptr(dev, props); 94 uint32_t mask = qdev_get_prop_mask(props); 95 if (val) { 96 *p |= mask; 97 } else { 98 *p &= ~mask; 99 } 100 } 101 102 static void prop_get_bit(Object *obj, Visitor *v, const char *name, 103 void *opaque, Error **errp) 104 { 105 DeviceState *dev = DEVICE(obj); 106 Property *prop = opaque; 107 uint32_t *p = qdev_get_prop_ptr(dev, prop); 108 bool value = (*p & qdev_get_prop_mask(prop)) != 0; 109 110 visit_type_bool(v, name, &value, errp); 111 } 112 113 static void prop_set_bit(Object *obj, Visitor *v, const char *name, 114 void *opaque, Error **errp) 115 { 116 DeviceState *dev = DEVICE(obj); 117 Property *prop = opaque; 118 Error *local_err = NULL; 119 bool value; 120 121 if (dev->realized) { 122 qdev_prop_set_after_realize(dev, name, errp); 123 return; 124 } 125 126 visit_type_bool(v, name, &value, &local_err); 127 if (local_err) { 128 error_propagate(errp, local_err); 129 return; 130 } 131 bit_prop_set(dev, prop, value); 132 } 133 134 static void set_default_value_bool(ObjectProperty *op, const Property *prop) 135 { 136 object_property_set_default_bool(op, prop->defval.u); 137 } 138 139 const PropertyInfo qdev_prop_bit = { 140 .name = "bool", 141 .description = "on/off", 142 .get = prop_get_bit, 143 .set = prop_set_bit, 144 .set_default_value = set_default_value_bool, 145 }; 146 147 /* Bit64 */ 148 149 static uint64_t qdev_get_prop_mask64(Property *prop) 150 { 151 assert(prop->info == &qdev_prop_bit64); 152 return 0x1ull << prop->bitnr; 153 } 154 155 static void bit64_prop_set(DeviceState *dev, Property *props, bool val) 156 { 157 uint64_t *p = qdev_get_prop_ptr(dev, props); 158 uint64_t mask = qdev_get_prop_mask64(props); 159 if (val) { 160 *p |= mask; 161 } else { 162 *p &= ~mask; 163 } 164 } 165 166 static void prop_get_bit64(Object *obj, Visitor *v, const char *name, 167 void *opaque, Error **errp) 168 { 169 DeviceState *dev = DEVICE(obj); 170 Property *prop = opaque; 171 uint64_t *p = qdev_get_prop_ptr(dev, prop); 172 bool value = (*p & qdev_get_prop_mask64(prop)) != 0; 173 174 visit_type_bool(v, name, &value, errp); 175 } 176 177 static void prop_set_bit64(Object *obj, Visitor *v, const char *name, 178 void *opaque, Error **errp) 179 { 180 DeviceState *dev = DEVICE(obj); 181 Property *prop = opaque; 182 Error *local_err = NULL; 183 bool value; 184 185 if (dev->realized) { 186 qdev_prop_set_after_realize(dev, name, errp); 187 return; 188 } 189 190 visit_type_bool(v, name, &value, &local_err); 191 if (local_err) { 192 error_propagate(errp, local_err); 193 return; 194 } 195 bit64_prop_set(dev, prop, value); 196 } 197 198 const PropertyInfo qdev_prop_bit64 = { 199 .name = "bool", 200 .description = "on/off", 201 .get = prop_get_bit64, 202 .set = prop_set_bit64, 203 .set_default_value = set_default_value_bool, 204 }; 205 206 /* --- bool --- */ 207 208 static void get_bool(Object *obj, Visitor *v, const char *name, void *opaque, 209 Error **errp) 210 { 211 DeviceState *dev = DEVICE(obj); 212 Property *prop = opaque; 213 bool *ptr = qdev_get_prop_ptr(dev, prop); 214 215 visit_type_bool(v, name, ptr, errp); 216 } 217 218 static void set_bool(Object *obj, Visitor *v, const char *name, void *opaque, 219 Error **errp) 220 { 221 DeviceState *dev = DEVICE(obj); 222 Property *prop = opaque; 223 bool *ptr = qdev_get_prop_ptr(dev, prop); 224 225 if (dev->realized) { 226 qdev_prop_set_after_realize(dev, name, errp); 227 return; 228 } 229 230 visit_type_bool(v, name, ptr, errp); 231 } 232 233 const PropertyInfo qdev_prop_bool = { 234 .name = "bool", 235 .get = get_bool, 236 .set = set_bool, 237 .set_default_value = set_default_value_bool, 238 }; 239 240 /* --- 8bit integer --- */ 241 242 static void get_uint8(Object *obj, Visitor *v, const char *name, void *opaque, 243 Error **errp) 244 { 245 DeviceState *dev = DEVICE(obj); 246 Property *prop = opaque; 247 uint8_t *ptr = qdev_get_prop_ptr(dev, prop); 248 249 visit_type_uint8(v, name, ptr, errp); 250 } 251 252 static void set_uint8(Object *obj, Visitor *v, const char *name, void *opaque, 253 Error **errp) 254 { 255 DeviceState *dev = DEVICE(obj); 256 Property *prop = opaque; 257 uint8_t *ptr = qdev_get_prop_ptr(dev, prop); 258 259 if (dev->realized) { 260 qdev_prop_set_after_realize(dev, name, errp); 261 return; 262 } 263 264 visit_type_uint8(v, name, ptr, errp); 265 } 266 267 static void set_default_value_int(ObjectProperty *op, const Property *prop) 268 { 269 object_property_set_default_int(op, prop->defval.i); 270 } 271 272 static void set_default_value_uint(ObjectProperty *op, const Property *prop) 273 { 274 object_property_set_default_uint(op, prop->defval.u); 275 } 276 277 const PropertyInfo qdev_prop_uint8 = { 278 .name = "uint8", 279 .get = get_uint8, 280 .set = set_uint8, 281 .set_default_value = set_default_value_uint, 282 }; 283 284 /* --- 16bit integer --- */ 285 286 static void get_uint16(Object *obj, Visitor *v, const char *name, 287 void *opaque, Error **errp) 288 { 289 DeviceState *dev = DEVICE(obj); 290 Property *prop = opaque; 291 uint16_t *ptr = qdev_get_prop_ptr(dev, prop); 292 293 visit_type_uint16(v, name, ptr, errp); 294 } 295 296 static void set_uint16(Object *obj, Visitor *v, const char *name, 297 void *opaque, Error **errp) 298 { 299 DeviceState *dev = DEVICE(obj); 300 Property *prop = opaque; 301 uint16_t *ptr = qdev_get_prop_ptr(dev, prop); 302 303 if (dev->realized) { 304 qdev_prop_set_after_realize(dev, name, errp); 305 return; 306 } 307 308 visit_type_uint16(v, name, ptr, errp); 309 } 310 311 const PropertyInfo qdev_prop_uint16 = { 312 .name = "uint16", 313 .get = get_uint16, 314 .set = set_uint16, 315 .set_default_value = set_default_value_uint, 316 }; 317 318 /* --- 32bit integer --- */ 319 320 static void get_uint32(Object *obj, Visitor *v, const char *name, 321 void *opaque, Error **errp) 322 { 323 DeviceState *dev = DEVICE(obj); 324 Property *prop = opaque; 325 uint32_t *ptr = qdev_get_prop_ptr(dev, prop); 326 327 visit_type_uint32(v, name, ptr, errp); 328 } 329 330 static void set_uint32(Object *obj, Visitor *v, const char *name, 331 void *opaque, Error **errp) 332 { 333 DeviceState *dev = DEVICE(obj); 334 Property *prop = opaque; 335 uint32_t *ptr = qdev_get_prop_ptr(dev, prop); 336 337 if (dev->realized) { 338 qdev_prop_set_after_realize(dev, name, errp); 339 return; 340 } 341 342 visit_type_uint32(v, name, ptr, errp); 343 } 344 345 static void get_int32(Object *obj, Visitor *v, const char *name, void *opaque, 346 Error **errp) 347 { 348 DeviceState *dev = DEVICE(obj); 349 Property *prop = opaque; 350 int32_t *ptr = qdev_get_prop_ptr(dev, prop); 351 352 visit_type_int32(v, name, ptr, errp); 353 } 354 355 static void set_int32(Object *obj, Visitor *v, const char *name, void *opaque, 356 Error **errp) 357 { 358 DeviceState *dev = DEVICE(obj); 359 Property *prop = opaque; 360 int32_t *ptr = qdev_get_prop_ptr(dev, prop); 361 362 if (dev->realized) { 363 qdev_prop_set_after_realize(dev, name, errp); 364 return; 365 } 366 367 visit_type_int32(v, name, ptr, errp); 368 } 369 370 const PropertyInfo qdev_prop_uint32 = { 371 .name = "uint32", 372 .get = get_uint32, 373 .set = set_uint32, 374 .set_default_value = set_default_value_uint, 375 }; 376 377 const PropertyInfo qdev_prop_int32 = { 378 .name = "int32", 379 .get = get_int32, 380 .set = set_int32, 381 .set_default_value = set_default_value_int, 382 }; 383 384 /* --- 64bit integer --- */ 385 386 static void get_uint64(Object *obj, Visitor *v, const char *name, 387 void *opaque, Error **errp) 388 { 389 DeviceState *dev = DEVICE(obj); 390 Property *prop = opaque; 391 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 392 393 visit_type_uint64(v, name, ptr, errp); 394 } 395 396 static void set_uint64(Object *obj, Visitor *v, const char *name, 397 void *opaque, Error **errp) 398 { 399 DeviceState *dev = DEVICE(obj); 400 Property *prop = opaque; 401 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 402 403 if (dev->realized) { 404 qdev_prop_set_after_realize(dev, name, errp); 405 return; 406 } 407 408 visit_type_uint64(v, name, ptr, errp); 409 } 410 411 static void get_int64(Object *obj, Visitor *v, const char *name, 412 void *opaque, Error **errp) 413 { 414 DeviceState *dev = DEVICE(obj); 415 Property *prop = opaque; 416 int64_t *ptr = qdev_get_prop_ptr(dev, prop); 417 418 visit_type_int64(v, name, ptr, errp); 419 } 420 421 static void set_int64(Object *obj, Visitor *v, const char *name, 422 void *opaque, Error **errp) 423 { 424 DeviceState *dev = DEVICE(obj); 425 Property *prop = opaque; 426 int64_t *ptr = qdev_get_prop_ptr(dev, prop); 427 428 if (dev->realized) { 429 qdev_prop_set_after_realize(dev, name, errp); 430 return; 431 } 432 433 visit_type_int64(v, name, ptr, errp); 434 } 435 436 const PropertyInfo qdev_prop_uint64 = { 437 .name = "uint64", 438 .get = get_uint64, 439 .set = set_uint64, 440 .set_default_value = set_default_value_uint, 441 }; 442 443 const PropertyInfo qdev_prop_int64 = { 444 .name = "int64", 445 .get = get_int64, 446 .set = set_int64, 447 .set_default_value = set_default_value_int, 448 }; 449 450 /* --- string --- */ 451 452 static void release_string(Object *obj, const char *name, void *opaque) 453 { 454 Property *prop = opaque; 455 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop)); 456 } 457 458 static void get_string(Object *obj, Visitor *v, const char *name, 459 void *opaque, Error **errp) 460 { 461 DeviceState *dev = DEVICE(obj); 462 Property *prop = opaque; 463 char **ptr = qdev_get_prop_ptr(dev, prop); 464 465 if (!*ptr) { 466 char *str = (char *)""; 467 visit_type_str(v, name, &str, errp); 468 } else { 469 visit_type_str(v, name, ptr, errp); 470 } 471 } 472 473 static void set_string(Object *obj, Visitor *v, const char *name, 474 void *opaque, Error **errp) 475 { 476 DeviceState *dev = DEVICE(obj); 477 Property *prop = opaque; 478 char **ptr = qdev_get_prop_ptr(dev, prop); 479 Error *local_err = NULL; 480 char *str; 481 482 if (dev->realized) { 483 qdev_prop_set_after_realize(dev, name, errp); 484 return; 485 } 486 487 visit_type_str(v, name, &str, &local_err); 488 if (local_err) { 489 error_propagate(errp, local_err); 490 return; 491 } 492 g_free(*ptr); 493 *ptr = str; 494 } 495 496 const PropertyInfo qdev_prop_string = { 497 .name = "str", 498 .release = release_string, 499 .get = get_string, 500 .set = set_string, 501 }; 502 503 /* --- mac address --- */ 504 505 /* 506 * accepted syntax versions: 507 * 01:02:03:04:05:06 508 * 01-02-03-04-05-06 509 */ 510 static void get_mac(Object *obj, Visitor *v, const char *name, void *opaque, 511 Error **errp) 512 { 513 DeviceState *dev = DEVICE(obj); 514 Property *prop = opaque; 515 MACAddr *mac = qdev_get_prop_ptr(dev, prop); 516 char buffer[2 * 6 + 5 + 1]; 517 char *p = buffer; 518 519 snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x", 520 mac->a[0], mac->a[1], mac->a[2], 521 mac->a[3], mac->a[4], mac->a[5]); 522 523 visit_type_str(v, name, &p, errp); 524 } 525 526 static void set_mac(Object *obj, Visitor *v, const char *name, void *opaque, 527 Error **errp) 528 { 529 DeviceState *dev = DEVICE(obj); 530 Property *prop = opaque; 531 MACAddr *mac = qdev_get_prop_ptr(dev, prop); 532 Error *local_err = NULL; 533 int i, pos; 534 char *str, *p; 535 536 if (dev->realized) { 537 qdev_prop_set_after_realize(dev, name, errp); 538 return; 539 } 540 541 visit_type_str(v, name, &str, &local_err); 542 if (local_err) { 543 error_propagate(errp, local_err); 544 return; 545 } 546 547 for (i = 0, pos = 0; i < 6; i++, pos += 3) { 548 if (!qemu_isxdigit(str[pos])) { 549 goto inval; 550 } 551 if (!qemu_isxdigit(str[pos+1])) { 552 goto inval; 553 } 554 if (i == 5) { 555 if (str[pos+2] != '\0') { 556 goto inval; 557 } 558 } else { 559 if (str[pos+2] != ':' && str[pos+2] != '-') { 560 goto inval; 561 } 562 } 563 mac->a[i] = strtol(str+pos, &p, 16); 564 } 565 g_free(str); 566 return; 567 568 inval: 569 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); 570 g_free(str); 571 } 572 573 const PropertyInfo qdev_prop_macaddr = { 574 .name = "str", 575 .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56", 576 .get = get_mac, 577 .set = set_mac, 578 }; 579 580 /* --- on/off/auto --- */ 581 582 const PropertyInfo qdev_prop_on_off_auto = { 583 .name = "OnOffAuto", 584 .description = "on/off/auto", 585 .enum_table = &OnOffAuto_lookup, 586 .get = get_enum, 587 .set = set_enum, 588 .set_default_value = set_default_value_enum, 589 }; 590 591 /* --- lost tick policy --- */ 592 593 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int)); 594 595 const PropertyInfo qdev_prop_losttickpolicy = { 596 .name = "LostTickPolicy", 597 .enum_table = &LostTickPolicy_lookup, 598 .get = get_enum, 599 .set = set_enum, 600 .set_default_value = set_default_value_enum, 601 }; 602 603 /* --- Block device error handling policy --- */ 604 605 QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError) != sizeof(int)); 606 607 const PropertyInfo qdev_prop_blockdev_on_error = { 608 .name = "BlockdevOnError", 609 .description = "Error handling policy, " 610 "report/ignore/enospc/stop/auto", 611 .enum_table = &BlockdevOnError_lookup, 612 .get = get_enum, 613 .set = set_enum, 614 .set_default_value = set_default_value_enum, 615 }; 616 617 /* --- BIOS CHS translation */ 618 619 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int)); 620 621 const PropertyInfo qdev_prop_bios_chs_trans = { 622 .name = "BiosAtaTranslation", 623 .description = "Logical CHS translation algorithm, " 624 "auto/none/lba/large/rechs", 625 .enum_table = &BiosAtaTranslation_lookup, 626 .get = get_enum, 627 .set = set_enum, 628 .set_default_value = set_default_value_enum, 629 }; 630 631 /* --- FDC default drive types */ 632 633 const PropertyInfo qdev_prop_fdc_drive_type = { 634 .name = "FdcDriveType", 635 .description = "FDC drive type, " 636 "144/288/120/none/auto", 637 .enum_table = &FloppyDriveType_lookup, 638 .get = get_enum, 639 .set = set_enum, 640 .set_default_value = set_default_value_enum, 641 }; 642 643 /* --- MultiFDCompression --- */ 644 645 const PropertyInfo qdev_prop_multifd_compression = { 646 .name = "MultiFDCompression", 647 .description = "multifd_compression values, " 648 "none/zlib/zstd", 649 .enum_table = &MultiFDCompression_lookup, 650 .get = get_enum, 651 .set = set_enum, 652 .set_default_value = set_default_value_enum, 653 }; 654 655 /* --- pci address --- */ 656 657 /* 658 * bus-local address, i.e. "$slot" or "$slot.$fn" 659 */ 660 static void set_pci_devfn(Object *obj, Visitor *v, const char *name, 661 void *opaque, Error **errp) 662 { 663 DeviceState *dev = DEVICE(obj); 664 Property *prop = opaque; 665 int32_t value, *ptr = qdev_get_prop_ptr(dev, prop); 666 unsigned int slot, fn, n; 667 Error *local_err = NULL; 668 char *str; 669 670 if (dev->realized) { 671 qdev_prop_set_after_realize(dev, name, errp); 672 return; 673 } 674 675 visit_type_str(v, name, &str, &local_err); 676 if (local_err) { 677 error_free(local_err); 678 local_err = NULL; 679 visit_type_int32(v, name, &value, &local_err); 680 if (local_err) { 681 error_propagate(errp, local_err); 682 } else if (value < -1 || value > 255) { 683 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 684 name ? name : "null", "pci_devfn"); 685 } else { 686 *ptr = value; 687 } 688 return; 689 } 690 691 if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) { 692 fn = 0; 693 if (sscanf(str, "%x%n", &slot, &n) != 1) { 694 goto invalid; 695 } 696 } 697 if (str[n] != '\0' || fn > 7 || slot > 31) { 698 goto invalid; 699 } 700 *ptr = slot << 3 | fn; 701 g_free(str); 702 return; 703 704 invalid: 705 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); 706 g_free(str); 707 } 708 709 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, 710 size_t len) 711 { 712 int32_t *ptr = qdev_get_prop_ptr(dev, prop); 713 714 if (*ptr == -1) { 715 return snprintf(dest, len, "<unset>"); 716 } else { 717 return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7); 718 } 719 } 720 721 const PropertyInfo qdev_prop_pci_devfn = { 722 .name = "int32", 723 .description = "Slot and optional function number, example: 06.0 or 06", 724 .print = print_pci_devfn, 725 .get = get_int32, 726 .set = set_pci_devfn, 727 .set_default_value = set_default_value_int, 728 }; 729 730 /* --- blocksize --- */ 731 732 static void set_blocksize(Object *obj, Visitor *v, const char *name, 733 void *opaque, Error **errp) 734 { 735 DeviceState *dev = DEVICE(obj); 736 Property *prop = opaque; 737 uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop); 738 Error *local_err = NULL; 739 const int64_t min = 512; 740 const int64_t max = 32768; 741 742 if (dev->realized) { 743 qdev_prop_set_after_realize(dev, name, errp); 744 return; 745 } 746 747 visit_type_uint16(v, name, &value, &local_err); 748 if (local_err) { 749 error_propagate(errp, local_err); 750 return; 751 } 752 /* value of 0 means "unset" */ 753 if (value && (value < min || value > max)) { 754 error_setg(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, 755 dev->id ? : "", name, (int64_t)value, min, max); 756 return; 757 } 758 759 /* We rely on power-of-2 blocksizes for bitmasks */ 760 if ((value & (value - 1)) != 0) { 761 error_setg(errp, 762 "Property %s.%s doesn't take value '%" PRId64 "', it's not a power of 2", 763 dev->id ?: "", name, (int64_t)value); 764 return; 765 } 766 767 *ptr = value; 768 } 769 770 const PropertyInfo qdev_prop_blocksize = { 771 .name = "uint16", 772 .description = "A power of two between 512 and 32768", 773 .get = get_uint16, 774 .set = set_blocksize, 775 .set_default_value = set_default_value_uint, 776 }; 777 778 /* --- pci host address --- */ 779 780 static void get_pci_host_devaddr(Object *obj, Visitor *v, const char *name, 781 void *opaque, Error **errp) 782 { 783 DeviceState *dev = DEVICE(obj); 784 Property *prop = opaque; 785 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop); 786 char buffer[] = "ffff:ff:ff.f"; 787 char *p = buffer; 788 int rc = 0; 789 790 /* 791 * Catch "invalid" device reference from vfio-pci and allow the 792 * default buffer representing the non-existent device to be used. 793 */ 794 if (~addr->domain || ~addr->bus || ~addr->slot || ~addr->function) { 795 rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%0d", 796 addr->domain, addr->bus, addr->slot, addr->function); 797 assert(rc == sizeof(buffer) - 1); 798 } 799 800 visit_type_str(v, name, &p, errp); 801 } 802 803 /* 804 * Parse [<domain>:]<bus>:<slot>.<func> 805 * if <domain> is not supplied, it's assumed to be 0. 806 */ 807 static void set_pci_host_devaddr(Object *obj, Visitor *v, const char *name, 808 void *opaque, Error **errp) 809 { 810 DeviceState *dev = DEVICE(obj); 811 Property *prop = opaque; 812 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop); 813 Error *local_err = NULL; 814 char *str, *p; 815 char *e; 816 unsigned long val; 817 unsigned long dom = 0, bus = 0; 818 unsigned int slot = 0, func = 0; 819 820 if (dev->realized) { 821 qdev_prop_set_after_realize(dev, name, errp); 822 return; 823 } 824 825 visit_type_str(v, name, &str, &local_err); 826 if (local_err) { 827 error_propagate(errp, local_err); 828 return; 829 } 830 831 p = str; 832 val = strtoul(p, &e, 16); 833 if (e == p || *e != ':') { 834 goto inval; 835 } 836 bus = val; 837 838 p = e + 1; 839 val = strtoul(p, &e, 16); 840 if (e == p) { 841 goto inval; 842 } 843 if (*e == ':') { 844 dom = bus; 845 bus = val; 846 p = e + 1; 847 val = strtoul(p, &e, 16); 848 if (e == p) { 849 goto inval; 850 } 851 } 852 slot = val; 853 854 if (*e != '.') { 855 goto inval; 856 } 857 p = e + 1; 858 val = strtoul(p, &e, 10); 859 if (e == p) { 860 goto inval; 861 } 862 func = val; 863 864 if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) { 865 goto inval; 866 } 867 868 if (*e) { 869 goto inval; 870 } 871 872 addr->domain = dom; 873 addr->bus = bus; 874 addr->slot = slot; 875 addr->function = func; 876 877 g_free(str); 878 return; 879 880 inval: 881 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); 882 g_free(str); 883 } 884 885 const PropertyInfo qdev_prop_pci_host_devaddr = { 886 .name = "str", 887 .description = "Address (bus/device/function) of " 888 "the host device, example: 04:10.0", 889 .get = get_pci_host_devaddr, 890 .set = set_pci_host_devaddr, 891 }; 892 893 /* --- UUID --- */ 894 895 static void get_uuid(Object *obj, Visitor *v, const char *name, void *opaque, 896 Error **errp) 897 { 898 DeviceState *dev = DEVICE(obj); 899 Property *prop = opaque; 900 QemuUUID *uuid = qdev_get_prop_ptr(dev, prop); 901 char buffer[UUID_FMT_LEN + 1]; 902 char *p = buffer; 903 904 qemu_uuid_unparse(uuid, buffer); 905 906 visit_type_str(v, name, &p, errp); 907 } 908 909 #define UUID_VALUE_AUTO "auto" 910 911 static void set_uuid(Object *obj, Visitor *v, const char *name, void *opaque, 912 Error **errp) 913 { 914 DeviceState *dev = DEVICE(obj); 915 Property *prop = opaque; 916 QemuUUID *uuid = qdev_get_prop_ptr(dev, prop); 917 Error *local_err = NULL; 918 char *str; 919 920 if (dev->realized) { 921 qdev_prop_set_after_realize(dev, name, errp); 922 return; 923 } 924 925 visit_type_str(v, name, &str, &local_err); 926 if (local_err) { 927 error_propagate(errp, local_err); 928 return; 929 } 930 931 if (!strcmp(str, UUID_VALUE_AUTO)) { 932 qemu_uuid_generate(uuid); 933 } else if (qemu_uuid_parse(str, uuid) < 0) { 934 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); 935 } 936 g_free(str); 937 } 938 939 static void set_default_uuid_auto(ObjectProperty *op, const Property *prop) 940 { 941 object_property_set_default_str(op, UUID_VALUE_AUTO); 942 } 943 944 const PropertyInfo qdev_prop_uuid = { 945 .name = "str", 946 .description = "UUID (aka GUID) or \"" UUID_VALUE_AUTO 947 "\" for random value (default)", 948 .get = get_uuid, 949 .set = set_uuid, 950 .set_default_value = set_default_uuid_auto, 951 }; 952 953 /* --- support for array properties --- */ 954 955 /* Used as an opaque for the object properties we add for each 956 * array element. Note that the struct Property must be first 957 * in the struct so that a pointer to this works as the opaque 958 * for the underlying element's property hooks as well as for 959 * our own release callback. 960 */ 961 typedef struct { 962 struct Property prop; 963 char *propname; 964 ObjectPropertyRelease *release; 965 } ArrayElementProperty; 966 967 /* object property release callback for array element properties: 968 * we call the underlying element's property release hook, and 969 * then free the memory we allocated when we added the property. 970 */ 971 static void array_element_release(Object *obj, const char *name, void *opaque) 972 { 973 ArrayElementProperty *p = opaque; 974 if (p->release) { 975 p->release(obj, name, opaque); 976 } 977 g_free(p->propname); 978 g_free(p); 979 } 980 981 static void set_prop_arraylen(Object *obj, Visitor *v, const char *name, 982 void *opaque, Error **errp) 983 { 984 /* Setter for the property which defines the length of a 985 * variable-sized property array. As well as actually setting the 986 * array-length field in the device struct, we have to create the 987 * array itself and dynamically add the corresponding properties. 988 */ 989 DeviceState *dev = DEVICE(obj); 990 Property *prop = opaque; 991 uint32_t *alenptr = qdev_get_prop_ptr(dev, prop); 992 void **arrayptr = (void *)dev + prop->arrayoffset; 993 Error *local_err = NULL; 994 void *eltptr; 995 const char *arrayname; 996 int i; 997 998 if (dev->realized) { 999 qdev_prop_set_after_realize(dev, name, errp); 1000 return; 1001 } 1002 if (*alenptr) { 1003 error_setg(errp, "array size property %s may not be set more than once", 1004 name); 1005 return; 1006 } 1007 visit_type_uint32(v, name, alenptr, &local_err); 1008 if (local_err) { 1009 error_propagate(errp, local_err); 1010 return; 1011 } 1012 if (!*alenptr) { 1013 return; 1014 } 1015 1016 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix; 1017 * strip it off so we can get the name of the array itself. 1018 */ 1019 assert(strncmp(name, PROP_ARRAY_LEN_PREFIX, 1020 strlen(PROP_ARRAY_LEN_PREFIX)) == 0); 1021 arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX); 1022 1023 /* Note that it is the responsibility of the individual device's deinit 1024 * to free the array proper. 1025 */ 1026 *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize); 1027 for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) { 1028 char *propname = g_strdup_printf("%s[%d]", arrayname, i); 1029 ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1); 1030 arrayprop->release = prop->arrayinfo->release; 1031 arrayprop->propname = propname; 1032 arrayprop->prop.info = prop->arrayinfo; 1033 arrayprop->prop.name = propname; 1034 /* This ugly piece of pointer arithmetic sets up the offset so 1035 * that when the underlying get/set hooks call qdev_get_prop_ptr 1036 * they get the right answer despite the array element not actually 1037 * being inside the device struct. 1038 */ 1039 arrayprop->prop.offset = eltptr - (void *)dev; 1040 assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr); 1041 object_property_add(obj, propname, 1042 arrayprop->prop.info->name, 1043 arrayprop->prop.info->get, 1044 arrayprop->prop.info->set, 1045 array_element_release, 1046 arrayprop); 1047 } 1048 } 1049 1050 const PropertyInfo qdev_prop_arraylen = { 1051 .name = "uint32", 1052 .get = get_uint32, 1053 .set = set_prop_arraylen, 1054 .set_default_value = set_default_value_uint, 1055 }; 1056 1057 /* --- public helpers --- */ 1058 1059 static Property *qdev_prop_walk(Property *props, const char *name) 1060 { 1061 if (!props) { 1062 return NULL; 1063 } 1064 while (props->name) { 1065 if (strcmp(props->name, name) == 0) { 1066 return props; 1067 } 1068 props++; 1069 } 1070 return NULL; 1071 } 1072 1073 static Property *qdev_prop_find(DeviceState *dev, const char *name) 1074 { 1075 ObjectClass *class; 1076 Property *prop; 1077 1078 /* device properties */ 1079 class = object_get_class(OBJECT(dev)); 1080 do { 1081 prop = qdev_prop_walk(DEVICE_CLASS(class)->props_, name); 1082 if (prop) { 1083 return prop; 1084 } 1085 class = object_class_get_parent(class); 1086 } while (class != object_class_by_name(TYPE_DEVICE)); 1087 1088 return NULL; 1089 } 1090 1091 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev, 1092 Property *prop, const char *value) 1093 { 1094 switch (ret) { 1095 case -EEXIST: 1096 error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use", 1097 object_get_typename(OBJECT(dev)), prop->name, value); 1098 break; 1099 default: 1100 case -EINVAL: 1101 error_setg(errp, QERR_PROPERTY_VALUE_BAD, 1102 object_get_typename(OBJECT(dev)), prop->name, value); 1103 break; 1104 case -ENOENT: 1105 error_setg(errp, "Property '%s.%s' can't find value '%s'", 1106 object_get_typename(OBJECT(dev)), prop->name, value); 1107 break; 1108 case 0: 1109 break; 1110 } 1111 } 1112 1113 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value) 1114 { 1115 object_property_set_bool(OBJECT(dev), value, name, &error_abort); 1116 } 1117 1118 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value) 1119 { 1120 object_property_set_int(OBJECT(dev), value, name, &error_abort); 1121 } 1122 1123 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value) 1124 { 1125 object_property_set_int(OBJECT(dev), value, name, &error_abort); 1126 } 1127 1128 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value) 1129 { 1130 object_property_set_int(OBJECT(dev), value, name, &error_abort); 1131 } 1132 1133 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value) 1134 { 1135 object_property_set_int(OBJECT(dev), value, name, &error_abort); 1136 } 1137 1138 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value) 1139 { 1140 object_property_set_int(OBJECT(dev), value, name, &error_abort); 1141 } 1142 1143 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value) 1144 { 1145 object_property_set_str(OBJECT(dev), value, name, &error_abort); 1146 } 1147 1148 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, 1149 const uint8_t *value) 1150 { 1151 char str[2 * 6 + 5 + 1]; 1152 snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x", 1153 value[0], value[1], value[2], value[3], value[4], value[5]); 1154 1155 object_property_set_str(OBJECT(dev), str, name, &error_abort); 1156 } 1157 1158 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value) 1159 { 1160 Property *prop; 1161 1162 prop = qdev_prop_find(dev, name); 1163 object_property_set_str(OBJECT(dev), 1164 qapi_enum_lookup(prop->info->enum_table, value), 1165 name, &error_abort); 1166 } 1167 1168 static GPtrArray *global_props(void) 1169 { 1170 static GPtrArray *gp; 1171 1172 if (!gp) { 1173 gp = g_ptr_array_new(); 1174 } 1175 1176 return gp; 1177 } 1178 1179 void qdev_prop_register_global(GlobalProperty *prop) 1180 { 1181 g_ptr_array_add(global_props(), prop); 1182 } 1183 1184 int qdev_prop_check_globals(void) 1185 { 1186 int i, ret = 0; 1187 1188 for (i = 0; i < global_props()->len; i++) { 1189 GlobalProperty *prop; 1190 ObjectClass *oc; 1191 DeviceClass *dc; 1192 1193 prop = g_ptr_array_index(global_props(), i); 1194 if (prop->used) { 1195 continue; 1196 } 1197 oc = object_class_by_name(prop->driver); 1198 oc = object_class_dynamic_cast(oc, TYPE_DEVICE); 1199 if (!oc) { 1200 warn_report("global %s.%s has invalid class name", 1201 prop->driver, prop->property); 1202 ret = 1; 1203 continue; 1204 } 1205 dc = DEVICE_CLASS(oc); 1206 if (!dc->hotpluggable && !prop->used) { 1207 warn_report("global %s.%s=%s not used", 1208 prop->driver, prop->property, prop->value); 1209 ret = 1; 1210 continue; 1211 } 1212 } 1213 return ret; 1214 } 1215 1216 void qdev_prop_set_globals(DeviceState *dev) 1217 { 1218 object_apply_global_props(OBJECT(dev), global_props(), 1219 dev->hotplugged ? NULL : &error_fatal); 1220 } 1221 1222 /* --- 64bit unsigned int 'size' type --- */ 1223 1224 static void get_size(Object *obj, Visitor *v, const char *name, void *opaque, 1225 Error **errp) 1226 { 1227 DeviceState *dev = DEVICE(obj); 1228 Property *prop = opaque; 1229 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 1230 1231 visit_type_size(v, name, ptr, errp); 1232 } 1233 1234 static void set_size(Object *obj, Visitor *v, const char *name, void *opaque, 1235 Error **errp) 1236 { 1237 DeviceState *dev = DEVICE(obj); 1238 Property *prop = opaque; 1239 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 1240 1241 visit_type_size(v, name, ptr, errp); 1242 } 1243 1244 const PropertyInfo qdev_prop_size = { 1245 .name = "size", 1246 .get = get_size, 1247 .set = set_size, 1248 .set_default_value = set_default_value_uint, 1249 }; 1250 1251 /* --- object link property --- */ 1252 1253 static void create_link_property(ObjectClass *oc, Property *prop) 1254 { 1255 object_class_property_add_link(oc, prop->name, prop->link_type, 1256 prop->offset, 1257 qdev_prop_allow_set_link_before_realize, 1258 OBJ_PROP_LINK_STRONG); 1259 } 1260 1261 const PropertyInfo qdev_prop_link = { 1262 .name = "link", 1263 .create = create_link_property, 1264 }; 1265 1266 /* --- OffAutoPCIBAR off/auto/bar0/bar1/bar2/bar3/bar4/bar5 --- */ 1267 1268 const PropertyInfo qdev_prop_off_auto_pcibar = { 1269 .name = "OffAutoPCIBAR", 1270 .description = "off/auto/bar0/bar1/bar2/bar3/bar4/bar5", 1271 .enum_table = &OffAutoPCIBAR_lookup, 1272 .get = get_enum, 1273 .set = set_enum, 1274 .set_default_value = set_default_value_enum, 1275 }; 1276 1277 /* --- PCIELinkSpeed 2_5/5/8/16 -- */ 1278 1279 static void get_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name, 1280 void *opaque, Error **errp) 1281 { 1282 DeviceState *dev = DEVICE(obj); 1283 Property *prop = opaque; 1284 PCIExpLinkSpeed *p = qdev_get_prop_ptr(dev, prop); 1285 int speed; 1286 1287 switch (*p) { 1288 case QEMU_PCI_EXP_LNK_2_5GT: 1289 speed = PCIE_LINK_SPEED_2_5; 1290 break; 1291 case QEMU_PCI_EXP_LNK_5GT: 1292 speed = PCIE_LINK_SPEED_5; 1293 break; 1294 case QEMU_PCI_EXP_LNK_8GT: 1295 speed = PCIE_LINK_SPEED_8; 1296 break; 1297 case QEMU_PCI_EXP_LNK_16GT: 1298 speed = PCIE_LINK_SPEED_16; 1299 break; 1300 default: 1301 /* Unreachable */ 1302 abort(); 1303 } 1304 1305 visit_type_enum(v, prop->name, &speed, prop->info->enum_table, errp); 1306 } 1307 1308 static void set_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name, 1309 void *opaque, Error **errp) 1310 { 1311 DeviceState *dev = DEVICE(obj); 1312 Property *prop = opaque; 1313 PCIExpLinkSpeed *p = qdev_get_prop_ptr(dev, prop); 1314 int speed; 1315 Error *local_err = NULL; 1316 1317 if (dev->realized) { 1318 qdev_prop_set_after_realize(dev, name, errp); 1319 return; 1320 } 1321 1322 visit_type_enum(v, prop->name, &speed, prop->info->enum_table, &local_err); 1323 if (local_err) { 1324 error_propagate(errp, local_err); 1325 return; 1326 } 1327 1328 switch (speed) { 1329 case PCIE_LINK_SPEED_2_5: 1330 *p = QEMU_PCI_EXP_LNK_2_5GT; 1331 break; 1332 case PCIE_LINK_SPEED_5: 1333 *p = QEMU_PCI_EXP_LNK_5GT; 1334 break; 1335 case PCIE_LINK_SPEED_8: 1336 *p = QEMU_PCI_EXP_LNK_8GT; 1337 break; 1338 case PCIE_LINK_SPEED_16: 1339 *p = QEMU_PCI_EXP_LNK_16GT; 1340 break; 1341 default: 1342 /* Unreachable */ 1343 abort(); 1344 } 1345 } 1346 1347 const PropertyInfo qdev_prop_pcie_link_speed = { 1348 .name = "PCIELinkSpeed", 1349 .description = "2_5/5/8/16", 1350 .enum_table = &PCIELinkSpeed_lookup, 1351 .get = get_prop_pcielinkspeed, 1352 .set = set_prop_pcielinkspeed, 1353 .set_default_value = set_default_value_enum, 1354 }; 1355 1356 /* --- PCIELinkWidth 1/2/4/8/12/16/32 -- */ 1357 1358 static void get_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name, 1359 void *opaque, Error **errp) 1360 { 1361 DeviceState *dev = DEVICE(obj); 1362 Property *prop = opaque; 1363 PCIExpLinkWidth *p = qdev_get_prop_ptr(dev, prop); 1364 int width; 1365 1366 switch (*p) { 1367 case QEMU_PCI_EXP_LNK_X1: 1368 width = PCIE_LINK_WIDTH_1; 1369 break; 1370 case QEMU_PCI_EXP_LNK_X2: 1371 width = PCIE_LINK_WIDTH_2; 1372 break; 1373 case QEMU_PCI_EXP_LNK_X4: 1374 width = PCIE_LINK_WIDTH_4; 1375 break; 1376 case QEMU_PCI_EXP_LNK_X8: 1377 width = PCIE_LINK_WIDTH_8; 1378 break; 1379 case QEMU_PCI_EXP_LNK_X12: 1380 width = PCIE_LINK_WIDTH_12; 1381 break; 1382 case QEMU_PCI_EXP_LNK_X16: 1383 width = PCIE_LINK_WIDTH_16; 1384 break; 1385 case QEMU_PCI_EXP_LNK_X32: 1386 width = PCIE_LINK_WIDTH_32; 1387 break; 1388 default: 1389 /* Unreachable */ 1390 abort(); 1391 } 1392 1393 visit_type_enum(v, prop->name, &width, prop->info->enum_table, errp); 1394 } 1395 1396 static void set_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name, 1397 void *opaque, Error **errp) 1398 { 1399 DeviceState *dev = DEVICE(obj); 1400 Property *prop = opaque; 1401 PCIExpLinkWidth *p = qdev_get_prop_ptr(dev, prop); 1402 int width; 1403 Error *local_err = NULL; 1404 1405 if (dev->realized) { 1406 qdev_prop_set_after_realize(dev, name, errp); 1407 return; 1408 } 1409 1410 visit_type_enum(v, prop->name, &width, prop->info->enum_table, &local_err); 1411 if (local_err) { 1412 error_propagate(errp, local_err); 1413 return; 1414 } 1415 1416 switch (width) { 1417 case PCIE_LINK_WIDTH_1: 1418 *p = QEMU_PCI_EXP_LNK_X1; 1419 break; 1420 case PCIE_LINK_WIDTH_2: 1421 *p = QEMU_PCI_EXP_LNK_X2; 1422 break; 1423 case PCIE_LINK_WIDTH_4: 1424 *p = QEMU_PCI_EXP_LNK_X4; 1425 break; 1426 case PCIE_LINK_WIDTH_8: 1427 *p = QEMU_PCI_EXP_LNK_X8; 1428 break; 1429 case PCIE_LINK_WIDTH_12: 1430 *p = QEMU_PCI_EXP_LNK_X12; 1431 break; 1432 case PCIE_LINK_WIDTH_16: 1433 *p = QEMU_PCI_EXP_LNK_X16; 1434 break; 1435 case PCIE_LINK_WIDTH_32: 1436 *p = QEMU_PCI_EXP_LNK_X32; 1437 break; 1438 default: 1439 /* Unreachable */ 1440 abort(); 1441 } 1442 } 1443 1444 const PropertyInfo qdev_prop_pcie_link_width = { 1445 .name = "PCIELinkWidth", 1446 .description = "1/2/4/8/12/16/32", 1447 .enum_table = &PCIELinkWidth_lookup, 1448 .get = get_prop_pcielinkwidth, 1449 .set = set_prop_pcielinkwidth, 1450 .set_default_value = set_default_value_enum, 1451 }; 1452