1 #include "net/net.h" 2 #include "hw/qdev.h" 3 #include "qapi/qmp/qerror.h" 4 #include "sysemu/block-backend.h" 5 #include "hw/block/block.h" 6 #include "net/hub.h" 7 #include "qapi/visitor.h" 8 #include "sysemu/char.h" 9 10 void qdev_prop_set_after_realize(DeviceState *dev, const char *name, 11 Error **errp) 12 { 13 if (dev->id) { 14 error_setg(errp, "Attempt to set property '%s' on device '%s' " 15 "(type '%s') after it was realized", name, dev->id, 16 object_get_typename(OBJECT(dev))); 17 } else { 18 error_setg(errp, "Attempt to set property '%s' on anonymous device " 19 "(type '%s') after it was realized", name, 20 object_get_typename(OBJECT(dev))); 21 } 22 } 23 24 void qdev_prop_allow_set_link_before_realize(Object *obj, const char *name, 25 Object *val, Error **errp) 26 { 27 DeviceState *dev = DEVICE(obj); 28 29 if (dev->realized) { 30 error_setg(errp, "Attempt to set link property '%s' on device '%s' " 31 "(type '%s') after it was realized", 32 name, dev->id, object_get_typename(obj)); 33 } 34 } 35 36 void *qdev_get_prop_ptr(DeviceState *dev, Property *prop) 37 { 38 void *ptr = dev; 39 ptr += prop->offset; 40 return ptr; 41 } 42 43 static void get_enum(Object *obj, Visitor *v, void *opaque, 44 const char *name, Error **errp) 45 { 46 DeviceState *dev = DEVICE(obj); 47 Property *prop = opaque; 48 int *ptr = qdev_get_prop_ptr(dev, prop); 49 50 visit_type_enum(v, ptr, prop->info->enum_table, 51 prop->info->name, prop->name, errp); 52 } 53 54 static void set_enum(Object *obj, Visitor *v, void *opaque, 55 const char *name, Error **errp) 56 { 57 DeviceState *dev = DEVICE(obj); 58 Property *prop = opaque; 59 int *ptr = qdev_get_prop_ptr(dev, prop); 60 61 if (dev->realized) { 62 qdev_prop_set_after_realize(dev, name, errp); 63 return; 64 } 65 66 visit_type_enum(v, ptr, prop->info->enum_table, 67 prop->info->name, prop->name, errp); 68 } 69 70 /* Bit */ 71 72 static uint32_t qdev_get_prop_mask(Property *prop) 73 { 74 assert(prop->info == &qdev_prop_bit); 75 return 0x1 << prop->bitnr; 76 } 77 78 static void bit_prop_set(DeviceState *dev, Property *props, bool val) 79 { 80 uint32_t *p = qdev_get_prop_ptr(dev, props); 81 uint32_t mask = qdev_get_prop_mask(props); 82 if (val) { 83 *p |= mask; 84 } else { 85 *p &= ~mask; 86 } 87 } 88 89 static void prop_get_bit(Object *obj, Visitor *v, void *opaque, 90 const char *name, Error **errp) 91 { 92 DeviceState *dev = DEVICE(obj); 93 Property *prop = opaque; 94 uint32_t *p = qdev_get_prop_ptr(dev, prop); 95 bool value = (*p & qdev_get_prop_mask(prop)) != 0; 96 97 visit_type_bool(v, &value, name, errp); 98 } 99 100 static void prop_set_bit(Object *obj, Visitor *v, void *opaque, 101 const char *name, Error **errp) 102 { 103 DeviceState *dev = DEVICE(obj); 104 Property *prop = opaque; 105 Error *local_err = NULL; 106 bool value; 107 108 if (dev->realized) { 109 qdev_prop_set_after_realize(dev, name, errp); 110 return; 111 } 112 113 visit_type_bool(v, &value, name, &local_err); 114 if (local_err) { 115 error_propagate(errp, local_err); 116 return; 117 } 118 bit_prop_set(dev, prop, value); 119 } 120 121 PropertyInfo qdev_prop_bit = { 122 .name = "bool", 123 .description = "on/off", 124 .get = prop_get_bit, 125 .set = prop_set_bit, 126 }; 127 128 /* --- bool --- */ 129 130 static void get_bool(Object *obj, Visitor *v, void *opaque, 131 const char *name, Error **errp) 132 { 133 DeviceState *dev = DEVICE(obj); 134 Property *prop = opaque; 135 bool *ptr = qdev_get_prop_ptr(dev, prop); 136 137 visit_type_bool(v, ptr, name, errp); 138 } 139 140 static void set_bool(Object *obj, Visitor *v, void *opaque, 141 const char *name, Error **errp) 142 { 143 DeviceState *dev = DEVICE(obj); 144 Property *prop = opaque; 145 bool *ptr = qdev_get_prop_ptr(dev, prop); 146 147 if (dev->realized) { 148 qdev_prop_set_after_realize(dev, name, errp); 149 return; 150 } 151 152 visit_type_bool(v, ptr, name, errp); 153 } 154 155 PropertyInfo qdev_prop_bool = { 156 .name = "bool", 157 .get = get_bool, 158 .set = set_bool, 159 }; 160 161 /* --- 8bit integer --- */ 162 163 static void get_uint8(Object *obj, Visitor *v, void *opaque, 164 const char *name, Error **errp) 165 { 166 DeviceState *dev = DEVICE(obj); 167 Property *prop = opaque; 168 uint8_t *ptr = qdev_get_prop_ptr(dev, prop); 169 170 visit_type_uint8(v, ptr, name, errp); 171 } 172 173 static void set_uint8(Object *obj, Visitor *v, void *opaque, 174 const char *name, Error **errp) 175 { 176 DeviceState *dev = DEVICE(obj); 177 Property *prop = opaque; 178 uint8_t *ptr = qdev_get_prop_ptr(dev, prop); 179 180 if (dev->realized) { 181 qdev_prop_set_after_realize(dev, name, errp); 182 return; 183 } 184 185 visit_type_uint8(v, ptr, name, errp); 186 } 187 188 PropertyInfo qdev_prop_uint8 = { 189 .name = "uint8", 190 .get = get_uint8, 191 .set = set_uint8, 192 }; 193 194 /* --- 16bit integer --- */ 195 196 static void get_uint16(Object *obj, Visitor *v, void *opaque, 197 const char *name, Error **errp) 198 { 199 DeviceState *dev = DEVICE(obj); 200 Property *prop = opaque; 201 uint16_t *ptr = qdev_get_prop_ptr(dev, prop); 202 203 visit_type_uint16(v, ptr, name, errp); 204 } 205 206 static void set_uint16(Object *obj, Visitor *v, void *opaque, 207 const char *name, Error **errp) 208 { 209 DeviceState *dev = DEVICE(obj); 210 Property *prop = opaque; 211 uint16_t *ptr = qdev_get_prop_ptr(dev, prop); 212 213 if (dev->realized) { 214 qdev_prop_set_after_realize(dev, name, errp); 215 return; 216 } 217 218 visit_type_uint16(v, ptr, name, errp); 219 } 220 221 PropertyInfo qdev_prop_uint16 = { 222 .name = "uint16", 223 .get = get_uint16, 224 .set = set_uint16, 225 }; 226 227 /* --- 32bit integer --- */ 228 229 static void get_uint32(Object *obj, Visitor *v, void *opaque, 230 const char *name, Error **errp) 231 { 232 DeviceState *dev = DEVICE(obj); 233 Property *prop = opaque; 234 uint32_t *ptr = qdev_get_prop_ptr(dev, prop); 235 236 visit_type_uint32(v, ptr, name, errp); 237 } 238 239 static void set_uint32(Object *obj, Visitor *v, void *opaque, 240 const char *name, Error **errp) 241 { 242 DeviceState *dev = DEVICE(obj); 243 Property *prop = opaque; 244 uint32_t *ptr = qdev_get_prop_ptr(dev, prop); 245 246 if (dev->realized) { 247 qdev_prop_set_after_realize(dev, name, errp); 248 return; 249 } 250 251 visit_type_uint32(v, ptr, name, errp); 252 } 253 254 static void get_int32(Object *obj, Visitor *v, void *opaque, 255 const char *name, Error **errp) 256 { 257 DeviceState *dev = DEVICE(obj); 258 Property *prop = opaque; 259 int32_t *ptr = qdev_get_prop_ptr(dev, prop); 260 261 visit_type_int32(v, ptr, name, errp); 262 } 263 264 static void set_int32(Object *obj, Visitor *v, void *opaque, 265 const char *name, Error **errp) 266 { 267 DeviceState *dev = DEVICE(obj); 268 Property *prop = opaque; 269 int32_t *ptr = qdev_get_prop_ptr(dev, prop); 270 271 if (dev->realized) { 272 qdev_prop_set_after_realize(dev, name, errp); 273 return; 274 } 275 276 visit_type_int32(v, ptr, name, errp); 277 } 278 279 PropertyInfo qdev_prop_uint32 = { 280 .name = "uint32", 281 .get = get_uint32, 282 .set = set_uint32, 283 }; 284 285 PropertyInfo qdev_prop_int32 = { 286 .name = "int32", 287 .get = get_int32, 288 .set = set_int32, 289 }; 290 291 /* --- 64bit integer --- */ 292 293 static void get_uint64(Object *obj, Visitor *v, void *opaque, 294 const char *name, Error **errp) 295 { 296 DeviceState *dev = DEVICE(obj); 297 Property *prop = opaque; 298 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 299 300 visit_type_uint64(v, ptr, name, errp); 301 } 302 303 static void set_uint64(Object *obj, Visitor *v, void *opaque, 304 const char *name, Error **errp) 305 { 306 DeviceState *dev = DEVICE(obj); 307 Property *prop = opaque; 308 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 309 310 if (dev->realized) { 311 qdev_prop_set_after_realize(dev, name, errp); 312 return; 313 } 314 315 visit_type_uint64(v, ptr, name, errp); 316 } 317 318 PropertyInfo qdev_prop_uint64 = { 319 .name = "uint64", 320 .get = get_uint64, 321 .set = set_uint64, 322 }; 323 324 /* --- string --- */ 325 326 static void release_string(Object *obj, const char *name, void *opaque) 327 { 328 Property *prop = opaque; 329 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop)); 330 } 331 332 static void get_string(Object *obj, Visitor *v, void *opaque, 333 const char *name, Error **errp) 334 { 335 DeviceState *dev = DEVICE(obj); 336 Property *prop = opaque; 337 char **ptr = qdev_get_prop_ptr(dev, prop); 338 339 if (!*ptr) { 340 char *str = (char *)""; 341 visit_type_str(v, &str, name, errp); 342 } else { 343 visit_type_str(v, ptr, name, errp); 344 } 345 } 346 347 static void set_string(Object *obj, Visitor *v, void *opaque, 348 const char *name, Error **errp) 349 { 350 DeviceState *dev = DEVICE(obj); 351 Property *prop = opaque; 352 char **ptr = qdev_get_prop_ptr(dev, prop); 353 Error *local_err = NULL; 354 char *str; 355 356 if (dev->realized) { 357 qdev_prop_set_after_realize(dev, name, errp); 358 return; 359 } 360 361 visit_type_str(v, &str, name, &local_err); 362 if (local_err) { 363 error_propagate(errp, local_err); 364 return; 365 } 366 if (*ptr) { 367 g_free(*ptr); 368 } 369 *ptr = str; 370 } 371 372 PropertyInfo qdev_prop_string = { 373 .name = "str", 374 .release = release_string, 375 .get = get_string, 376 .set = set_string, 377 }; 378 379 /* --- pointer --- */ 380 381 /* Not a proper property, just for dirty hacks. TODO Remove it! */ 382 PropertyInfo qdev_prop_ptr = { 383 .name = "ptr", 384 }; 385 386 /* --- mac address --- */ 387 388 /* 389 * accepted syntax versions: 390 * 01:02:03:04:05:06 391 * 01-02-03-04-05-06 392 */ 393 static void get_mac(Object *obj, Visitor *v, void *opaque, 394 const char *name, Error **errp) 395 { 396 DeviceState *dev = DEVICE(obj); 397 Property *prop = opaque; 398 MACAddr *mac = qdev_get_prop_ptr(dev, prop); 399 char buffer[2 * 6 + 5 + 1]; 400 char *p = buffer; 401 402 snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x", 403 mac->a[0], mac->a[1], mac->a[2], 404 mac->a[3], mac->a[4], mac->a[5]); 405 406 visit_type_str(v, &p, name, errp); 407 } 408 409 static void set_mac(Object *obj, Visitor *v, void *opaque, 410 const char *name, Error **errp) 411 { 412 DeviceState *dev = DEVICE(obj); 413 Property *prop = opaque; 414 MACAddr *mac = qdev_get_prop_ptr(dev, prop); 415 Error *local_err = NULL; 416 int i, pos; 417 char *str, *p; 418 419 if (dev->realized) { 420 qdev_prop_set_after_realize(dev, name, errp); 421 return; 422 } 423 424 visit_type_str(v, &str, name, &local_err); 425 if (local_err) { 426 error_propagate(errp, local_err); 427 return; 428 } 429 430 for (i = 0, pos = 0; i < 6; i++, pos += 3) { 431 if (!qemu_isxdigit(str[pos])) { 432 goto inval; 433 } 434 if (!qemu_isxdigit(str[pos+1])) { 435 goto inval; 436 } 437 if (i == 5) { 438 if (str[pos+2] != '\0') { 439 goto inval; 440 } 441 } else { 442 if (str[pos+2] != ':' && str[pos+2] != '-') { 443 goto inval; 444 } 445 } 446 mac->a[i] = strtol(str+pos, &p, 16); 447 } 448 g_free(str); 449 return; 450 451 inval: 452 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); 453 g_free(str); 454 } 455 456 PropertyInfo qdev_prop_macaddr = { 457 .name = "str", 458 .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56", 459 .get = get_mac, 460 .set = set_mac, 461 }; 462 463 /* --- lost tick policy --- */ 464 465 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int)); 466 467 PropertyInfo qdev_prop_losttickpolicy = { 468 .name = "LostTickPolicy", 469 .enum_table = LostTickPolicy_lookup, 470 .get = get_enum, 471 .set = set_enum, 472 }; 473 474 /* --- BIOS CHS translation */ 475 476 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int)); 477 478 PropertyInfo qdev_prop_bios_chs_trans = { 479 .name = "BiosAtaTranslation", 480 .description = "Logical CHS translation algorithm, " 481 "auto/none/lba/large/rechs", 482 .enum_table = BiosAtaTranslation_lookup, 483 .get = get_enum, 484 .set = set_enum, 485 }; 486 487 /* --- pci address --- */ 488 489 /* 490 * bus-local address, i.e. "$slot" or "$slot.$fn" 491 */ 492 static void set_pci_devfn(Object *obj, Visitor *v, void *opaque, 493 const char *name, Error **errp) 494 { 495 DeviceState *dev = DEVICE(obj); 496 Property *prop = opaque; 497 int32_t value, *ptr = qdev_get_prop_ptr(dev, prop); 498 unsigned int slot, fn, n; 499 Error *local_err = NULL; 500 char *str; 501 502 if (dev->realized) { 503 qdev_prop_set_after_realize(dev, name, errp); 504 return; 505 } 506 507 visit_type_str(v, &str, name, &local_err); 508 if (local_err) { 509 error_free(local_err); 510 local_err = NULL; 511 visit_type_int32(v, &value, name, &local_err); 512 if (local_err) { 513 error_propagate(errp, local_err); 514 } else if (value < -1 || value > 255) { 515 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null", 516 "pci_devfn"); 517 } else { 518 *ptr = value; 519 } 520 return; 521 } 522 523 if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) { 524 fn = 0; 525 if (sscanf(str, "%x%n", &slot, &n) != 1) { 526 goto invalid; 527 } 528 } 529 if (str[n] != '\0' || fn > 7 || slot > 31) { 530 goto invalid; 531 } 532 *ptr = slot << 3 | fn; 533 g_free(str); 534 return; 535 536 invalid: 537 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); 538 g_free(str); 539 } 540 541 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, 542 size_t len) 543 { 544 int32_t *ptr = qdev_get_prop_ptr(dev, prop); 545 546 if (*ptr == -1) { 547 return snprintf(dest, len, "<unset>"); 548 } else { 549 return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7); 550 } 551 } 552 553 PropertyInfo qdev_prop_pci_devfn = { 554 .name = "int32", 555 .description = "Slot and optional function number, example: 06.0 or 06", 556 .print = print_pci_devfn, 557 .get = get_int32, 558 .set = set_pci_devfn, 559 }; 560 561 /* --- blocksize --- */ 562 563 static void set_blocksize(Object *obj, Visitor *v, void *opaque, 564 const char *name, Error **errp) 565 { 566 DeviceState *dev = DEVICE(obj); 567 Property *prop = opaque; 568 uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop); 569 Error *local_err = NULL; 570 const int64_t min = 512; 571 const int64_t max = 32768; 572 573 if (dev->realized) { 574 qdev_prop_set_after_realize(dev, name, errp); 575 return; 576 } 577 578 visit_type_uint16(v, &value, name, &local_err); 579 if (local_err) { 580 error_propagate(errp, local_err); 581 return; 582 } 583 if (value < min || value > max) { 584 error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, 585 dev->id?:"", name, (int64_t)value, min, max); 586 return; 587 } 588 589 /* We rely on power-of-2 blocksizes for bitmasks */ 590 if ((value & (value - 1)) != 0) { 591 error_setg(errp, 592 "Property %s.%s doesn't take value '%" PRId64 "', it's not a power of 2", 593 dev->id ?: "", name, (int64_t)value); 594 return; 595 } 596 597 *ptr = value; 598 } 599 600 PropertyInfo qdev_prop_blocksize = { 601 .name = "uint16", 602 .description = "A power of two between 512 and 32768", 603 .get = get_uint16, 604 .set = set_blocksize, 605 }; 606 607 /* --- pci host address --- */ 608 609 static void get_pci_host_devaddr(Object *obj, Visitor *v, void *opaque, 610 const char *name, Error **errp) 611 { 612 DeviceState *dev = DEVICE(obj); 613 Property *prop = opaque; 614 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop); 615 char buffer[] = "xxxx:xx:xx.x"; 616 char *p = buffer; 617 int rc = 0; 618 619 rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%d", 620 addr->domain, addr->bus, addr->slot, addr->function); 621 assert(rc == sizeof(buffer) - 1); 622 623 visit_type_str(v, &p, name, errp); 624 } 625 626 /* 627 * Parse [<domain>:]<bus>:<slot>.<func> 628 * if <domain> is not supplied, it's assumed to be 0. 629 */ 630 static void set_pci_host_devaddr(Object *obj, Visitor *v, void *opaque, 631 const char *name, Error **errp) 632 { 633 DeviceState *dev = DEVICE(obj); 634 Property *prop = opaque; 635 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop); 636 Error *local_err = NULL; 637 char *str, *p; 638 char *e; 639 unsigned long val; 640 unsigned long dom = 0, bus = 0; 641 unsigned int slot = 0, func = 0; 642 643 if (dev->realized) { 644 qdev_prop_set_after_realize(dev, name, errp); 645 return; 646 } 647 648 visit_type_str(v, &str, name, &local_err); 649 if (local_err) { 650 error_propagate(errp, local_err); 651 return; 652 } 653 654 p = str; 655 val = strtoul(p, &e, 16); 656 if (e == p || *e != ':') { 657 goto inval; 658 } 659 bus = val; 660 661 p = e + 1; 662 val = strtoul(p, &e, 16); 663 if (e == p) { 664 goto inval; 665 } 666 if (*e == ':') { 667 dom = bus; 668 bus = val; 669 p = e + 1; 670 val = strtoul(p, &e, 16); 671 if (e == p) { 672 goto inval; 673 } 674 } 675 slot = val; 676 677 if (*e != '.') { 678 goto inval; 679 } 680 p = e + 1; 681 val = strtoul(p, &e, 10); 682 if (e == p) { 683 goto inval; 684 } 685 func = val; 686 687 if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) { 688 goto inval; 689 } 690 691 if (*e) { 692 goto inval; 693 } 694 695 addr->domain = dom; 696 addr->bus = bus; 697 addr->slot = slot; 698 addr->function = func; 699 700 g_free(str); 701 return; 702 703 inval: 704 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); 705 g_free(str); 706 } 707 708 PropertyInfo qdev_prop_pci_host_devaddr = { 709 .name = "str", 710 .description = "Address (bus/device/function) of " 711 "the host device, example: 04:10.0", 712 .get = get_pci_host_devaddr, 713 .set = set_pci_host_devaddr, 714 }; 715 716 /* --- support for array properties --- */ 717 718 /* Used as an opaque for the object properties we add for each 719 * array element. Note that the struct Property must be first 720 * in the struct so that a pointer to this works as the opaque 721 * for the underlying element's property hooks as well as for 722 * our own release callback. 723 */ 724 typedef struct { 725 struct Property prop; 726 char *propname; 727 ObjectPropertyRelease *release; 728 } ArrayElementProperty; 729 730 /* object property release callback for array element properties: 731 * we call the underlying element's property release hook, and 732 * then free the memory we allocated when we added the property. 733 */ 734 static void array_element_release(Object *obj, const char *name, void *opaque) 735 { 736 ArrayElementProperty *p = opaque; 737 if (p->release) { 738 p->release(obj, name, opaque); 739 } 740 g_free(p->propname); 741 g_free(p); 742 } 743 744 static void set_prop_arraylen(Object *obj, Visitor *v, void *opaque, 745 const char *name, Error **errp) 746 { 747 /* Setter for the property which defines the length of a 748 * variable-sized property array. As well as actually setting the 749 * array-length field in the device struct, we have to create the 750 * array itself and dynamically add the corresponding properties. 751 */ 752 DeviceState *dev = DEVICE(obj); 753 Property *prop = opaque; 754 uint32_t *alenptr = qdev_get_prop_ptr(dev, prop); 755 void **arrayptr = (void *)dev + prop->arrayoffset; 756 Error *local_err = NULL; 757 void *eltptr; 758 const char *arrayname; 759 int i; 760 761 if (dev->realized) { 762 qdev_prop_set_after_realize(dev, name, errp); 763 return; 764 } 765 if (*alenptr) { 766 error_setg(errp, "array size property %s may not be set more than once", 767 name); 768 return; 769 } 770 visit_type_uint32(v, alenptr, name, &local_err); 771 if (local_err) { 772 error_propagate(errp, local_err); 773 return; 774 } 775 if (!*alenptr) { 776 return; 777 } 778 779 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix; 780 * strip it off so we can get the name of the array itself. 781 */ 782 assert(strncmp(name, PROP_ARRAY_LEN_PREFIX, 783 strlen(PROP_ARRAY_LEN_PREFIX)) == 0); 784 arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX); 785 786 /* Note that it is the responsibility of the individual device's deinit 787 * to free the array proper. 788 */ 789 *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize); 790 for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) { 791 char *propname = g_strdup_printf("%s[%d]", arrayname, i); 792 ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1); 793 arrayprop->release = prop->arrayinfo->release; 794 arrayprop->propname = propname; 795 arrayprop->prop.info = prop->arrayinfo; 796 arrayprop->prop.name = propname; 797 /* This ugly piece of pointer arithmetic sets up the offset so 798 * that when the underlying get/set hooks call qdev_get_prop_ptr 799 * they get the right answer despite the array element not actually 800 * being inside the device struct. 801 */ 802 arrayprop->prop.offset = eltptr - (void *)dev; 803 assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr); 804 object_property_add(obj, propname, 805 arrayprop->prop.info->name, 806 arrayprop->prop.info->get, 807 arrayprop->prop.info->set, 808 array_element_release, 809 arrayprop, &local_err); 810 if (local_err) { 811 error_propagate(errp, local_err); 812 return; 813 } 814 } 815 } 816 817 PropertyInfo qdev_prop_arraylen = { 818 .name = "uint32", 819 .get = get_uint32, 820 .set = set_prop_arraylen, 821 }; 822 823 /* --- public helpers --- */ 824 825 static Property *qdev_prop_walk(Property *props, const char *name) 826 { 827 if (!props) { 828 return NULL; 829 } 830 while (props->name) { 831 if (strcmp(props->name, name) == 0) { 832 return props; 833 } 834 props++; 835 } 836 return NULL; 837 } 838 839 static Property *qdev_prop_find(DeviceState *dev, const char *name) 840 { 841 ObjectClass *class; 842 Property *prop; 843 844 /* device properties */ 845 class = object_get_class(OBJECT(dev)); 846 do { 847 prop = qdev_prop_walk(DEVICE_CLASS(class)->props, name); 848 if (prop) { 849 return prop; 850 } 851 class = object_class_get_parent(class); 852 } while (class != object_class_by_name(TYPE_DEVICE)); 853 854 return NULL; 855 } 856 857 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev, 858 Property *prop, const char *value) 859 { 860 switch (ret) { 861 case -EEXIST: 862 error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use", 863 object_get_typename(OBJECT(dev)), prop->name, value); 864 break; 865 default: 866 case -EINVAL: 867 error_set(errp, QERR_PROPERTY_VALUE_BAD, 868 object_get_typename(OBJECT(dev)), prop->name, value); 869 break; 870 case -ENOENT: 871 error_setg(errp, "Property '%s.%s' can't find value '%s'", 872 object_get_typename(OBJECT(dev)), prop->name, value); 873 break; 874 case 0: 875 break; 876 } 877 } 878 879 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value) 880 { 881 object_property_set_bool(OBJECT(dev), value, name, &error_abort); 882 } 883 884 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value) 885 { 886 object_property_set_int(OBJECT(dev), value, name, &error_abort); 887 } 888 889 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value) 890 { 891 object_property_set_int(OBJECT(dev), value, name, &error_abort); 892 } 893 894 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value) 895 { 896 object_property_set_int(OBJECT(dev), value, name, &error_abort); 897 } 898 899 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value) 900 { 901 object_property_set_int(OBJECT(dev), value, name, &error_abort); 902 } 903 904 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value) 905 { 906 object_property_set_int(OBJECT(dev), value, name, &error_abort); 907 } 908 909 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value) 910 { 911 object_property_set_str(OBJECT(dev), value, name, &error_abort); 912 } 913 914 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value) 915 { 916 char str[2 * 6 + 5 + 1]; 917 snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x", 918 value[0], value[1], value[2], value[3], value[4], value[5]); 919 920 object_property_set_str(OBJECT(dev), str, name, &error_abort); 921 } 922 923 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value) 924 { 925 Property *prop; 926 927 prop = qdev_prop_find(dev, name); 928 object_property_set_str(OBJECT(dev), prop->info->enum_table[value], 929 name, &error_abort); 930 } 931 932 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value) 933 { 934 Property *prop; 935 void **ptr; 936 937 prop = qdev_prop_find(dev, name); 938 assert(prop && prop->info == &qdev_prop_ptr); 939 ptr = qdev_get_prop_ptr(dev, prop); 940 *ptr = value; 941 } 942 943 static QTAILQ_HEAD(, GlobalProperty) global_props = 944 QTAILQ_HEAD_INITIALIZER(global_props); 945 946 void qdev_prop_register_global(GlobalProperty *prop) 947 { 948 QTAILQ_INSERT_TAIL(&global_props, prop, next); 949 } 950 951 void qdev_prop_register_global_list(GlobalProperty *props) 952 { 953 int i; 954 955 for (i = 0; props[i].driver != NULL; i++) { 956 qdev_prop_register_global(props+i); 957 } 958 } 959 960 int qdev_prop_check_globals(void) 961 { 962 GlobalProperty *prop; 963 int ret = 0; 964 965 QTAILQ_FOREACH(prop, &global_props, next) { 966 ObjectClass *oc; 967 DeviceClass *dc; 968 if (prop->used) { 969 continue; 970 } 971 if (!prop->user_provided) { 972 continue; 973 } 974 oc = object_class_by_name(prop->driver); 975 oc = object_class_dynamic_cast(oc, TYPE_DEVICE); 976 if (!oc) { 977 error_report("Warning: global %s.%s has invalid class name", 978 prop->driver, prop->property); 979 ret = 1; 980 continue; 981 } 982 dc = DEVICE_CLASS(oc); 983 if (!dc->hotpluggable && !prop->used) { 984 error_report("Warning: global %s.%s=%s not used", 985 prop->driver, prop->property, prop->value); 986 ret = 1; 987 continue; 988 } 989 } 990 return ret; 991 } 992 993 void qdev_prop_set_globals_for_type(DeviceState *dev, const char *typename, 994 Error **errp) 995 { 996 GlobalProperty *prop; 997 998 QTAILQ_FOREACH(prop, &global_props, next) { 999 Error *err = NULL; 1000 1001 if (strcmp(typename, prop->driver) != 0) { 1002 continue; 1003 } 1004 prop->used = true; 1005 object_property_parse(OBJECT(dev), prop->value, prop->property, &err); 1006 if (err != NULL) { 1007 error_propagate(errp, err); 1008 return; 1009 } 1010 } 1011 } 1012 1013 void qdev_prop_set_globals(DeviceState *dev, Error **errp) 1014 { 1015 ObjectClass *class = object_get_class(OBJECT(dev)); 1016 1017 do { 1018 Error *err = NULL; 1019 1020 qdev_prop_set_globals_for_type(dev, object_class_get_name(class), 1021 &err); 1022 if (err != NULL) { 1023 error_propagate(errp, err); 1024 return; 1025 } 1026 class = object_class_get_parent(class); 1027 } while (class); 1028 } 1029 1030 /* --- 64bit unsigned int 'size' type --- */ 1031 1032 static void get_size(Object *obj, Visitor *v, void *opaque, 1033 const char *name, Error **errp) 1034 { 1035 DeviceState *dev = DEVICE(obj); 1036 Property *prop = opaque; 1037 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 1038 1039 visit_type_size(v, ptr, name, errp); 1040 } 1041 1042 static void set_size(Object *obj, Visitor *v, void *opaque, 1043 const char *name, Error **errp) 1044 { 1045 DeviceState *dev = DEVICE(obj); 1046 Property *prop = opaque; 1047 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 1048 1049 visit_type_size(v, ptr, name, errp); 1050 } 1051 1052 PropertyInfo qdev_prop_size = { 1053 .name = "size", 1054 .get = get_size, 1055 .set = set_size, 1056 }; 1057