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 /* value of 0 means "unset" */ 584 if (value && (value < min || value > max)) { 585 error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, 586 dev->id?:"", name, (int64_t)value, min, max); 587 return; 588 } 589 590 /* We rely on power-of-2 blocksizes for bitmasks */ 591 if ((value & (value - 1)) != 0) { 592 error_setg(errp, 593 "Property %s.%s doesn't take value '%" PRId64 "', it's not a power of 2", 594 dev->id ?: "", name, (int64_t)value); 595 return; 596 } 597 598 *ptr = value; 599 } 600 601 PropertyInfo qdev_prop_blocksize = { 602 .name = "uint16", 603 .description = "A power of two between 512 and 32768", 604 .get = get_uint16, 605 .set = set_blocksize, 606 }; 607 608 /* --- pci host address --- */ 609 610 static void get_pci_host_devaddr(Object *obj, Visitor *v, void *opaque, 611 const char *name, Error **errp) 612 { 613 DeviceState *dev = DEVICE(obj); 614 Property *prop = opaque; 615 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop); 616 char buffer[] = "xxxx:xx:xx.x"; 617 char *p = buffer; 618 int rc = 0; 619 620 rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%d", 621 addr->domain, addr->bus, addr->slot, addr->function); 622 assert(rc == sizeof(buffer) - 1); 623 624 visit_type_str(v, &p, name, errp); 625 } 626 627 /* 628 * Parse [<domain>:]<bus>:<slot>.<func> 629 * if <domain> is not supplied, it's assumed to be 0. 630 */ 631 static void set_pci_host_devaddr(Object *obj, Visitor *v, void *opaque, 632 const char *name, Error **errp) 633 { 634 DeviceState *dev = DEVICE(obj); 635 Property *prop = opaque; 636 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop); 637 Error *local_err = NULL; 638 char *str, *p; 639 char *e; 640 unsigned long val; 641 unsigned long dom = 0, bus = 0; 642 unsigned int slot = 0, func = 0; 643 644 if (dev->realized) { 645 qdev_prop_set_after_realize(dev, name, errp); 646 return; 647 } 648 649 visit_type_str(v, &str, name, &local_err); 650 if (local_err) { 651 error_propagate(errp, local_err); 652 return; 653 } 654 655 p = str; 656 val = strtoul(p, &e, 16); 657 if (e == p || *e != ':') { 658 goto inval; 659 } 660 bus = val; 661 662 p = e + 1; 663 val = strtoul(p, &e, 16); 664 if (e == p) { 665 goto inval; 666 } 667 if (*e == ':') { 668 dom = bus; 669 bus = val; 670 p = e + 1; 671 val = strtoul(p, &e, 16); 672 if (e == p) { 673 goto inval; 674 } 675 } 676 slot = val; 677 678 if (*e != '.') { 679 goto inval; 680 } 681 p = e + 1; 682 val = strtoul(p, &e, 10); 683 if (e == p) { 684 goto inval; 685 } 686 func = val; 687 688 if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) { 689 goto inval; 690 } 691 692 if (*e) { 693 goto inval; 694 } 695 696 addr->domain = dom; 697 addr->bus = bus; 698 addr->slot = slot; 699 addr->function = func; 700 701 g_free(str); 702 return; 703 704 inval: 705 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); 706 g_free(str); 707 } 708 709 PropertyInfo qdev_prop_pci_host_devaddr = { 710 .name = "str", 711 .description = "Address (bus/device/function) of " 712 "the host device, example: 04:10.0", 713 .get = get_pci_host_devaddr, 714 .set = set_pci_host_devaddr, 715 }; 716 717 /* --- support for array properties --- */ 718 719 /* Used as an opaque for the object properties we add for each 720 * array element. Note that the struct Property must be first 721 * in the struct so that a pointer to this works as the opaque 722 * for the underlying element's property hooks as well as for 723 * our own release callback. 724 */ 725 typedef struct { 726 struct Property prop; 727 char *propname; 728 ObjectPropertyRelease *release; 729 } ArrayElementProperty; 730 731 /* object property release callback for array element properties: 732 * we call the underlying element's property release hook, and 733 * then free the memory we allocated when we added the property. 734 */ 735 static void array_element_release(Object *obj, const char *name, void *opaque) 736 { 737 ArrayElementProperty *p = opaque; 738 if (p->release) { 739 p->release(obj, name, opaque); 740 } 741 g_free(p->propname); 742 g_free(p); 743 } 744 745 static void set_prop_arraylen(Object *obj, Visitor *v, void *opaque, 746 const char *name, Error **errp) 747 { 748 /* Setter for the property which defines the length of a 749 * variable-sized property array. As well as actually setting the 750 * array-length field in the device struct, we have to create the 751 * array itself and dynamically add the corresponding properties. 752 */ 753 DeviceState *dev = DEVICE(obj); 754 Property *prop = opaque; 755 uint32_t *alenptr = qdev_get_prop_ptr(dev, prop); 756 void **arrayptr = (void *)dev + prop->arrayoffset; 757 Error *local_err = NULL; 758 void *eltptr; 759 const char *arrayname; 760 int i; 761 762 if (dev->realized) { 763 qdev_prop_set_after_realize(dev, name, errp); 764 return; 765 } 766 if (*alenptr) { 767 error_setg(errp, "array size property %s may not be set more than once", 768 name); 769 return; 770 } 771 visit_type_uint32(v, alenptr, name, &local_err); 772 if (local_err) { 773 error_propagate(errp, local_err); 774 return; 775 } 776 if (!*alenptr) { 777 return; 778 } 779 780 /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix; 781 * strip it off so we can get the name of the array itself. 782 */ 783 assert(strncmp(name, PROP_ARRAY_LEN_PREFIX, 784 strlen(PROP_ARRAY_LEN_PREFIX)) == 0); 785 arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX); 786 787 /* Note that it is the responsibility of the individual device's deinit 788 * to free the array proper. 789 */ 790 *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize); 791 for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) { 792 char *propname = g_strdup_printf("%s[%d]", arrayname, i); 793 ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1); 794 arrayprop->release = prop->arrayinfo->release; 795 arrayprop->propname = propname; 796 arrayprop->prop.info = prop->arrayinfo; 797 arrayprop->prop.name = propname; 798 /* This ugly piece of pointer arithmetic sets up the offset so 799 * that when the underlying get/set hooks call qdev_get_prop_ptr 800 * they get the right answer despite the array element not actually 801 * being inside the device struct. 802 */ 803 arrayprop->prop.offset = eltptr - (void *)dev; 804 assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr); 805 object_property_add(obj, propname, 806 arrayprop->prop.info->name, 807 arrayprop->prop.info->get, 808 arrayprop->prop.info->set, 809 array_element_release, 810 arrayprop, &local_err); 811 if (local_err) { 812 error_propagate(errp, local_err); 813 return; 814 } 815 } 816 } 817 818 PropertyInfo qdev_prop_arraylen = { 819 .name = "uint32", 820 .get = get_uint32, 821 .set = set_prop_arraylen, 822 }; 823 824 /* --- public helpers --- */ 825 826 static Property *qdev_prop_walk(Property *props, const char *name) 827 { 828 if (!props) { 829 return NULL; 830 } 831 while (props->name) { 832 if (strcmp(props->name, name) == 0) { 833 return props; 834 } 835 props++; 836 } 837 return NULL; 838 } 839 840 static Property *qdev_prop_find(DeviceState *dev, const char *name) 841 { 842 ObjectClass *class; 843 Property *prop; 844 845 /* device properties */ 846 class = object_get_class(OBJECT(dev)); 847 do { 848 prop = qdev_prop_walk(DEVICE_CLASS(class)->props, name); 849 if (prop) { 850 return prop; 851 } 852 class = object_class_get_parent(class); 853 } while (class != object_class_by_name(TYPE_DEVICE)); 854 855 return NULL; 856 } 857 858 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev, 859 Property *prop, const char *value) 860 { 861 switch (ret) { 862 case -EEXIST: 863 error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use", 864 object_get_typename(OBJECT(dev)), prop->name, value); 865 break; 866 default: 867 case -EINVAL: 868 error_set(errp, QERR_PROPERTY_VALUE_BAD, 869 object_get_typename(OBJECT(dev)), prop->name, value); 870 break; 871 case -ENOENT: 872 error_setg(errp, "Property '%s.%s' can't find value '%s'", 873 object_get_typename(OBJECT(dev)), prop->name, value); 874 break; 875 case 0: 876 break; 877 } 878 } 879 880 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value) 881 { 882 object_property_set_bool(OBJECT(dev), value, name, &error_abort); 883 } 884 885 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value) 886 { 887 object_property_set_int(OBJECT(dev), value, name, &error_abort); 888 } 889 890 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value) 891 { 892 object_property_set_int(OBJECT(dev), value, name, &error_abort); 893 } 894 895 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value) 896 { 897 object_property_set_int(OBJECT(dev), value, name, &error_abort); 898 } 899 900 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value) 901 { 902 object_property_set_int(OBJECT(dev), value, name, &error_abort); 903 } 904 905 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value) 906 { 907 object_property_set_int(OBJECT(dev), value, name, &error_abort); 908 } 909 910 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value) 911 { 912 object_property_set_str(OBJECT(dev), value, name, &error_abort); 913 } 914 915 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value) 916 { 917 char str[2 * 6 + 5 + 1]; 918 snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x", 919 value[0], value[1], value[2], value[3], value[4], value[5]); 920 921 object_property_set_str(OBJECT(dev), str, name, &error_abort); 922 } 923 924 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value) 925 { 926 Property *prop; 927 928 prop = qdev_prop_find(dev, name); 929 object_property_set_str(OBJECT(dev), prop->info->enum_table[value], 930 name, &error_abort); 931 } 932 933 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value) 934 { 935 Property *prop; 936 void **ptr; 937 938 prop = qdev_prop_find(dev, name); 939 assert(prop && prop->info == &qdev_prop_ptr); 940 ptr = qdev_get_prop_ptr(dev, prop); 941 *ptr = value; 942 } 943 944 static QTAILQ_HEAD(, GlobalProperty) global_props = 945 QTAILQ_HEAD_INITIALIZER(global_props); 946 947 void qdev_prop_register_global(GlobalProperty *prop) 948 { 949 QTAILQ_INSERT_TAIL(&global_props, prop, next); 950 } 951 952 void qdev_prop_register_global_list(GlobalProperty *props) 953 { 954 int i; 955 956 for (i = 0; props[i].driver != NULL; i++) { 957 qdev_prop_register_global(props+i); 958 } 959 } 960 961 int qdev_prop_check_globals(void) 962 { 963 GlobalProperty *prop; 964 int ret = 0; 965 966 QTAILQ_FOREACH(prop, &global_props, next) { 967 ObjectClass *oc; 968 DeviceClass *dc; 969 if (prop->used) { 970 continue; 971 } 972 if (!prop->user_provided) { 973 continue; 974 } 975 oc = object_class_by_name(prop->driver); 976 oc = object_class_dynamic_cast(oc, TYPE_DEVICE); 977 if (!oc) { 978 error_report("Warning: global %s.%s has invalid class name", 979 prop->driver, prop->property); 980 ret = 1; 981 continue; 982 } 983 dc = DEVICE_CLASS(oc); 984 if (!dc->hotpluggable && !prop->used) { 985 error_report("Warning: global %s.%s=%s not used", 986 prop->driver, prop->property, prop->value); 987 ret = 1; 988 continue; 989 } 990 } 991 return ret; 992 } 993 994 static void qdev_prop_set_globals_for_type(DeviceState *dev, 995 const char *typename) 996 { 997 GlobalProperty *prop; 998 999 QTAILQ_FOREACH(prop, &global_props, next) { 1000 Error *err = NULL; 1001 1002 if (strcmp(typename, prop->driver) != 0) { 1003 continue; 1004 } 1005 prop->used = true; 1006 object_property_parse(OBJECT(dev), prop->value, prop->property, &err); 1007 if (err != NULL) { 1008 assert(prop->user_provided); 1009 error_report("Warning: global %s.%s=%s ignored (%s)", 1010 prop->driver, prop->property, prop->value, 1011 error_get_pretty(err)); 1012 error_free(err); 1013 return; 1014 } 1015 } 1016 } 1017 1018 void qdev_prop_set_globals(DeviceState *dev) 1019 { 1020 ObjectClass *class = object_get_class(OBJECT(dev)); 1021 1022 do { 1023 qdev_prop_set_globals_for_type(dev, object_class_get_name(class)); 1024 class = object_class_get_parent(class); 1025 } while (class); 1026 } 1027 1028 /* --- 64bit unsigned int 'size' type --- */ 1029 1030 static void get_size(Object *obj, Visitor *v, void *opaque, 1031 const char *name, Error **errp) 1032 { 1033 DeviceState *dev = DEVICE(obj); 1034 Property *prop = opaque; 1035 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 1036 1037 visit_type_size(v, ptr, name, errp); 1038 } 1039 1040 static void set_size(Object *obj, Visitor *v, void *opaque, 1041 const char *name, Error **errp) 1042 { 1043 DeviceState *dev = DEVICE(obj); 1044 Property *prop = opaque; 1045 uint64_t *ptr = qdev_get_prop_ptr(dev, prop); 1046 1047 visit_type_size(v, ptr, name, errp); 1048 } 1049 1050 PropertyInfo qdev_prop_size = { 1051 .name = "size", 1052 .get = get_size, 1053 .set = set_size, 1054 }; 1055