hw/core/qdev-properties.c

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