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