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.i],
  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.u, 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.i, prop->name, &error_abort);
 265 }
 266
 267 static void set_default_value_uint(Object *obj, const Property *prop)
 268 {
 269     object_property_set_uint(obj, prop->defval.u, prop->name, &error_abort);
 270 }
 271
 272 PropertyInfo qdev_prop_uint8 = {
 273     .name  = "uint8",
 274     .get   = get_uint8,
 275     .set   = set_uint8,
 276     .set_default_value = set_default_value_uint,
 277 };
 278
 279 /* --- 16bit integer --- */
 280
 281 static void get_uint16(Object *obj, Visitor *v, const char *name,
 282                        void *opaque, Error **errp)
 283 {
 284     DeviceState *dev = DEVICE(obj);
 285     Property *prop = opaque;
 286     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
 287
 288     visit_type_uint16(v, name, ptr, errp);
 289 }
 290
 291 static void set_uint16(Object *obj, Visitor *v, const char *name,
 292                        void *opaque, Error **errp)
 293 {
 294     DeviceState *dev = DEVICE(obj);
 295     Property *prop = opaque;
 296     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
 297
 298     if (dev->realized) {
 299         qdev_prop_set_after_realize(dev, name, errp);
 300         return;
 301     }
 302
 303     visit_type_uint16(v, name, ptr, errp);
 304 }
 305
 306 PropertyInfo qdev_prop_uint16 = {
 307     .name  = "uint16",
 308     .get   = get_uint16,
 309     .set   = set_uint16,
 310     .set_default_value = set_default_value_uint,
 311 };
 312
 313 /* --- 32bit integer --- */
 314
 315 static void get_uint32(Object *obj, Visitor *v, const char *name,
 316                        void *opaque, Error **errp)
 317 {
 318     DeviceState *dev = DEVICE(obj);
 319     Property *prop = opaque;
 320     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 321
 322     visit_type_uint32(v, name, ptr, errp);
 323 }
 324
 325 static void set_uint32(Object *obj, Visitor *v, const char *name,
 326                        void *opaque, Error **errp)
 327 {
 328     DeviceState *dev = DEVICE(obj);
 329     Property *prop = opaque;
 330     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 331
 332     if (dev->realized) {
 333         qdev_prop_set_after_realize(dev, name, errp);
 334         return;
 335     }
 336
 337     visit_type_uint32(v, name, ptr, errp);
 338 }
 339
 340 static void get_int32(Object *obj, Visitor *v, const char *name, void *opaque,
 341                       Error **errp)
 342 {
 343     DeviceState *dev = DEVICE(obj);
 344     Property *prop = opaque;
 345     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 346
 347     visit_type_int32(v, name, ptr, errp);
 348 }
 349
 350 static void set_int32(Object *obj, Visitor *v, const char *name, void *opaque,
 351                       Error **errp)
 352 {
 353     DeviceState *dev = DEVICE(obj);
 354     Property *prop = opaque;
 355     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 356
 357     if (dev->realized) {
 358         qdev_prop_set_after_realize(dev, name, errp);
 359         return;
 360     }
 361
 362     visit_type_int32(v, name, ptr, errp);
 363 }
 364
 365 PropertyInfo qdev_prop_uint32 = {
 366     .name  = "uint32",
 367     .get   = get_uint32,
 368     .set   = set_uint32,
 369     .set_default_value = set_default_value_uint,
 370 };
 371
 372 PropertyInfo qdev_prop_int32 = {
 373     .name  = "int32",
 374     .get   = get_int32,
 375     .set   = set_int32,
 376     .set_default_value = set_default_value_int,
 377 };
 378
 379 /* --- 64bit integer --- */
 380
 381 static void get_uint64(Object *obj, Visitor *v, const char *name,
 382                        void *opaque, Error **errp)
 383 {
 384     DeviceState *dev = DEVICE(obj);
 385     Property *prop = opaque;
 386     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 387
 388     visit_type_uint64(v, name, ptr, errp);
 389 }
 390
 391 static void set_uint64(Object *obj, Visitor *v, const char *name,
 392                        void *opaque, Error **errp)
 393 {
 394     DeviceState *dev = DEVICE(obj);
 395     Property *prop = opaque;
 396     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 397
 398     if (dev->realized) {
 399         qdev_prop_set_after_realize(dev, name, errp);
 400         return;
 401     }
 402
 403     visit_type_uint64(v, name, ptr, errp);
 404 }
 405
 406 PropertyInfo qdev_prop_uint64 = {
 407     .name  = "uint64",
 408     .get   = get_uint64,
 409     .set   = set_uint64,
 410     .set_default_value = set_default_value_uint,
 411 };
 412
 413 /* --- string --- */
 414
 415 static void release_string(Object *obj, const char *name, void *opaque)
 416 {
 417     Property *prop = opaque;
 418     g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop));
 419 }
 420
 421 static void get_string(Object *obj, Visitor *v, const char *name,
 422                        void *opaque, Error **errp)
 423 {
 424     DeviceState *dev = DEVICE(obj);
 425     Property *prop = opaque;
 426     char **ptr = qdev_get_prop_ptr(dev, prop);
 427
 428     if (!*ptr) {
 429         char *str = (char *)"";
 430         visit_type_str(v, name, &str, errp);
 431     } else {
 432         visit_type_str(v, name, ptr, errp);
 433     }
 434 }
 435
 436 static void set_string(Object *obj, Visitor *v, const char *name,
 437                        void *opaque, Error **errp)
 438 {
 439     DeviceState *dev = DEVICE(obj);
 440     Property *prop = opaque;
 441     char **ptr = qdev_get_prop_ptr(dev, prop);
 442     Error *local_err = NULL;
 443     char *str;
 444
 445     if (dev->realized) {
 446         qdev_prop_set_after_realize(dev, name, errp);
 447         return;
 448     }
 449
 450     visit_type_str(v, name, &str, &local_err);
 451     if (local_err) {
 452         error_propagate(errp, local_err);
 453         return;
 454     }
 455     g_free(*ptr);
 456     *ptr = str;
 457 }
 458
 459 PropertyInfo qdev_prop_string = {
 460     .name  = "str",
 461     .release = release_string,
 462     .get   = get_string,
 463     .set   = set_string,
 464 };
 465
 466 /* --- pointer --- */
 467
 468 /* Not a proper property, just for dirty hacks.  TODO Remove it!  */
 469 PropertyInfo qdev_prop_ptr = {
 470     .name  = "ptr",
 471 };
 472
 473 /* --- mac address --- */
 474
 475 /*
 476  * accepted syntax versions:
 477  *   01:02:03:04:05:06
 478  *   01-02-03-04-05-06
 479  */
 480 static void get_mac(Object *obj, Visitor *v, const char *name, void *opaque,
 481                     Error **errp)
 482 {
 483     DeviceState *dev = DEVICE(obj);
 484     Property *prop = opaque;
 485     MACAddr *mac = qdev_get_prop_ptr(dev, prop);
 486     char buffer[2 * 6 + 5 + 1];
 487     char *p = buffer;
 488
 489     snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
 490              mac->a[0], mac->a[1], mac->a[2],
 491              mac->a[3], mac->a[4], mac->a[5]);
 492
 493     visit_type_str(v, name, &p, errp);
 494 }
 495
 496 static void set_mac(Object *obj, Visitor *v, const char *name, void *opaque,
 497                     Error **errp)
 498 {
 499     DeviceState *dev = DEVICE(obj);
 500     Property *prop = opaque;
 501     MACAddr *mac = qdev_get_prop_ptr(dev, prop);
 502     Error *local_err = NULL;
 503     int i, pos;
 504     char *str, *p;
 505
 506     if (dev->realized) {
 507         qdev_prop_set_after_realize(dev, name, errp);
 508         return;
 509     }
 510
 511     visit_type_str(v, name, &str, &local_err);
 512     if (local_err) {
 513         error_propagate(errp, local_err);
 514         return;
 515     }
 516
 517     for (i = 0, pos = 0; i < 6; i++, pos += 3) {
 518         if (!qemu_isxdigit(str[pos])) {
 519             goto inval;
 520         }
 521         if (!qemu_isxdigit(str[pos+1])) {
 522             goto inval;
 523         }
 524         if (i == 5) {
 525             if (str[pos+2] != '\0') {
 526                 goto inval;
 527             }
 528         } else {
 529             if (str[pos+2] != ':' && str[pos+2] != '-') {
 530                 goto inval;
 531             }
 532         }
 533         mac->a[i] = strtol(str+pos, &p, 16);
 534     }
 535     g_free(str);
 536     return;
 537
 538 inval:
 539     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
 540     g_free(str);
 541 }
 542
 543 PropertyInfo qdev_prop_macaddr = {
 544     .name  = "str",
 545     .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
 546     .get   = get_mac,
 547     .set   = set_mac,
 548 };
 549
 550 /* --- on/off/auto --- */
 551
 552 PropertyInfo qdev_prop_on_off_auto = {
 553     .name = "OnOffAuto",
 554     .description = "on/off/auto",
 555     .enum_table = OnOffAuto_lookup,
 556     .get = get_enum,
 557     .set = set_enum,
 558     .set_default_value = set_default_value_enum,
 559 };
 560
 561 /* --- lost tick policy --- */
 562
 563 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int));
 564
 565 PropertyInfo qdev_prop_losttickpolicy = {
 566     .name  = "LostTickPolicy",
 567     .enum_table  = LostTickPolicy_lookup,
 568     .get   = get_enum,
 569     .set   = set_enum,
 570     .set_default_value = set_default_value_enum,
 571 };
 572
 573 /* --- Block device error handling policy --- */
 574
 575 QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError) != sizeof(int));
 576
 577 PropertyInfo qdev_prop_blockdev_on_error = {
 578     .name = "BlockdevOnError",
 579     .description = "Error handling policy, "
 580                    "report/ignore/enospc/stop/auto",
 581     .enum_table = BlockdevOnError_lookup,
 582     .get = get_enum,
 583     .set = set_enum,
 584     .set_default_value = set_default_value_enum,
 585 };
 586
 587 /* --- BIOS CHS translation */
 588
 589 QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int));
 590
 591 PropertyInfo qdev_prop_bios_chs_trans = {
 592     .name = "BiosAtaTranslation",
 593     .description = "Logical CHS translation algorithm, "
 594                    "auto/none/lba/large/rechs",
 595     .enum_table = BiosAtaTranslation_lookup,
 596     .get = get_enum,
 597     .set = set_enum,
 598     .set_default_value = set_default_value_enum,
 599 };
 600
 601 /* --- FDC default drive types */
 602
 603 PropertyInfo qdev_prop_fdc_drive_type = {
 604     .name = "FdcDriveType",
 605     .description = "FDC drive type, "
 606                    "144/288/120/none/auto",
 607     .enum_table = FloppyDriveType_lookup,
 608     .get = get_enum,
 609     .set = set_enum,
 610     .set_default_value = set_default_value_enum,
 611 };
 612
 613 /* --- pci address --- */
 614
 615 /*
 616  * bus-local address, i.e. "$slot" or "$slot.$fn"
 617  */
 618 static void set_pci_devfn(Object *obj, Visitor *v, const char *name,
 619                           void *opaque, Error **errp)
 620 {
 621     DeviceState *dev = DEVICE(obj);
 622     Property *prop = opaque;
 623     int32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
 624     unsigned int slot, fn, n;
 625     Error *local_err = NULL;
 626     char *str;
 627
 628     if (dev->realized) {
 629         qdev_prop_set_after_realize(dev, name, errp);
 630         return;
 631     }
 632
 633     visit_type_str(v, name, &str, &local_err);
 634     if (local_err) {
 635         error_free(local_err);
 636         local_err = NULL;
 637         visit_type_int32(v, name, &value, &local_err);
 638         if (local_err) {
 639             error_propagate(errp, local_err);
 640         } else if (value < -1 || value > 255) {
 641             error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 642                        name ? name : "null", "pci_devfn");
 643         } else {
 644             *ptr = value;
 645         }
 646         return;
 647     }
 648
 649     if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
 650         fn = 0;
 651         if (sscanf(str, "%x%n", &slot, &n) != 1) {
 652             goto invalid;
 653         }
 654     }
 655     if (str[n] != '\0' || fn > 7 || slot > 31) {
 656         goto invalid;
 657     }
 658     *ptr = slot << 3 | fn;
 659     g_free(str);
 660     return;
 661
 662 invalid:
 663     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
 664     g_free(str);
 665 }
 666
 667 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest,
 668                            size_t len)
 669 {
 670     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 671
 672     if (*ptr == -1) {
 673         return snprintf(dest, len, "<unset>");
 674     } else {
 675         return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
 676     }
 677 }
 678
 679 PropertyInfo qdev_prop_pci_devfn = {
 680     .name  = "int32",
 681     .description = "Slot and optional function number, example: 06.0 or 06",
 682     .print = print_pci_devfn,
 683     .get   = get_int32,
 684     .set   = set_pci_devfn,
 685     .set_default_value = set_default_value_int,
 686 };
 687
 688 /* --- blocksize --- */
 689
 690 static void set_blocksize(Object *obj, Visitor *v, const char *name,
 691                           void *opaque, Error **errp)
 692 {
 693     DeviceState *dev = DEVICE(obj);
 694     Property *prop = opaque;
 695     uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop);
 696     Error *local_err = NULL;
 697     const int64_t min = 512;
 698     const int64_t max = 32768;
 699
 700     if (dev->realized) {
 701         qdev_prop_set_after_realize(dev, name, errp);
 702         return;
 703     }
 704
 705     visit_type_uint16(v, name, &value, &local_err);
 706     if (local_err) {
 707         error_propagate(errp, local_err);
 708         return;
 709     }
 710     /* value of 0 means "unset" */
 711     if (value && (value < min || value > max)) {
 712         error_setg(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
 713                    dev->id ? : "", name, (int64_t)value, min, max);
 714         return;
 715     }
 716
 717     /* We rely on power-of-2 blocksizes for bitmasks */
 718     if ((value & (value - 1)) != 0) {
 719         error_setg(errp,
 720                   "Property %s.%s doesn't take value '%" PRId64 "', it's not a power of 2",
 721                   dev->id ?: "", name, (int64_t)value);
 722         return;
 723     }
 724
 725     *ptr = value;
 726 }
 727
 728 PropertyInfo qdev_prop_blocksize = {
 729     .name  = "uint16",
 730     .description = "A power of two between 512 and 32768",
 731     .get   = get_uint16,
 732     .set   = set_blocksize,
 733     .set_default_value = set_default_value_uint,
 734 };
 735
 736 /* --- pci host address --- */
 737
 738 static void get_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
 739                                  void *opaque, Error **errp)
 740 {
 741     DeviceState *dev = DEVICE(obj);
 742     Property *prop = opaque;
 743     PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
 744     char buffer[] = "ffff:ff:ff.f";
 745     char *p = buffer;
 746     int rc = 0;
 747
 748     /*
 749      * Catch "invalid" device reference from vfio-pci and allow the
 750      * default buffer representing the non-existent device to be used.
 751      */
 752     if (~addr->domain || ~addr->bus || ~addr->slot || ~addr->function) {
 753         rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%0d",
 754                       addr->domain, addr->bus, addr->slot, addr->function);
 755         assert(rc == sizeof(buffer) - 1);
 756     }
 757
 758     visit_type_str(v, name, &p, errp);
 759 }
 760
 761 /*
 762  * Parse [<domain>:]<bus>:<slot>.<func>
 763  *   if <domain> is not supplied, it's assumed to be 0.
 764  */
 765 static void set_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
 766                                  void *opaque, Error **errp)
 767 {
 768     DeviceState *dev = DEVICE(obj);
 769     Property *prop = opaque;
 770     PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
 771     Error *local_err = NULL;
 772     char *str, *p;
 773     char *e;
 774     unsigned long val;
 775     unsigned long dom = 0, bus = 0;
 776     unsigned int slot = 0, func = 0;
 777
 778     if (dev->realized) {
 779         qdev_prop_set_after_realize(dev, name, errp);
 780         return;
 781     }
 782
 783     visit_type_str(v, name, &str, &local_err);
 784     if (local_err) {
 785         error_propagate(errp, local_err);
 786         return;
 787     }
 788
 789     p = str;
 790     val = strtoul(p, &e, 16);
 791     if (e == p || *e != ':') {
 792         goto inval;
 793     }
 794     bus = val;
 795
 796     p = e + 1;
 797     val = strtoul(p, &e, 16);
 798     if (e == p) {
 799         goto inval;
 800     }
 801     if (*e == ':') {
 802         dom = bus;
 803         bus = val;
 804         p = e + 1;
 805         val = strtoul(p, &e, 16);
 806         if (e == p) {
 807             goto inval;
 808         }
 809     }
 810     slot = val;
 811
 812     if (*e != '.') {
 813         goto inval;
 814     }
 815     p = e + 1;
 816     val = strtoul(p, &e, 10);
 817     if (e == p) {
 818         goto inval;
 819     }
 820     func = val;
 821
 822     if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) {
 823         goto inval;
 824     }
 825
 826     if (*e) {
 827         goto inval;
 828     }
 829
 830     addr->domain = dom;
 831     addr->bus = bus;
 832     addr->slot = slot;
 833     addr->function = func;
 834
 835     g_free(str);
 836     return;
 837
 838 inval:
 839     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
 840     g_free(str);
 841 }
 842
 843 PropertyInfo qdev_prop_pci_host_devaddr = {
 844     .name = "str",
 845     .description = "Address (bus/device/function) of "
 846                    "the host device, example: 04:10.0",
 847     .get = get_pci_host_devaddr,
 848     .set = set_pci_host_devaddr,
 849 };
 850
 851 /* --- support for array properties --- */
 852
 853 /* Used as an opaque for the object properties we add for each
 854  * array element. Note that the struct Property must be first
 855  * in the struct so that a pointer to this works as the opaque
 856  * for the underlying element's property hooks as well as for
 857  * our own release callback.
 858  */
 859 typedef struct {
 860     struct Property prop;
 861     char *propname;
 862     ObjectPropertyRelease *release;
 863 } ArrayElementProperty;
 864
 865 /* object property release callback for array element properties:
 866  * we call the underlying element's property release hook, and
 867  * then free the memory we allocated when we added the property.
 868  */
 869 static void array_element_release(Object *obj, const char *name, void *opaque)
 870 {
 871     ArrayElementProperty *p = opaque;
 872     if (p->release) {
 873         p->release(obj, name, opaque);
 874     }
 875     g_free(p->propname);
 876     g_free(p);
 877 }
 878
 879 static void set_prop_arraylen(Object *obj, Visitor *v, const char *name,
 880                               void *opaque, Error **errp)
 881 {
 882     /* Setter for the property which defines the length of a
 883      * variable-sized property array. As well as actually setting the
 884      * array-length field in the device struct, we have to create the
 885      * array itself and dynamically add the corresponding properties.
 886      */
 887     DeviceState *dev = DEVICE(obj);
 888     Property *prop = opaque;
 889     uint32_t *alenptr = qdev_get_prop_ptr(dev, prop);
 890     void **arrayptr = (void *)dev + prop->arrayoffset;
 891     Error *local_err = NULL;
 892     void *eltptr;
 893     const char *arrayname;
 894     int i;
 895
 896     if (dev->realized) {
 897         qdev_prop_set_after_realize(dev, name, errp);
 898         return;
 899     }
 900     if (*alenptr) {
 901         error_setg(errp, "array size property %s may not be set more than once",
 902                    name);
 903         return;
 904     }
 905     visit_type_uint32(v, name, alenptr, &local_err);
 906     if (local_err) {
 907         error_propagate(errp, local_err);
 908         return;
 909     }
 910     if (!*alenptr) {
 911         return;
 912     }
 913
 914     /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix;
 915      * strip it off so we can get the name of the array itself.
 916      */
 917     assert(strncmp(name, PROP_ARRAY_LEN_PREFIX,
 918                    strlen(PROP_ARRAY_LEN_PREFIX)) == 0);
 919     arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX);
 920
 921     /* Note that it is the responsibility of the individual device's deinit
 922      * to free the array proper.
 923      */
 924     *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize);
 925     for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) {
 926         char *propname = g_strdup_printf("%s[%d]", arrayname, i);
 927         ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1);
 928         arrayprop->release = prop->arrayinfo->release;
 929         arrayprop->propname = propname;
 930         arrayprop->prop.info = prop->arrayinfo;
 931         arrayprop->prop.name = propname;
 932         /* This ugly piece of pointer arithmetic sets up the offset so
 933          * that when the underlying get/set hooks call qdev_get_prop_ptr
 934          * they get the right answer despite the array element not actually
 935          * being inside the device struct.
 936          */
 937         arrayprop->prop.offset = eltptr - (void *)dev;
 938         assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr);
 939         object_property_add(obj, propname,
 940                             arrayprop->prop.info->name,
 941                             arrayprop->prop.info->get,
 942                             arrayprop->prop.info->set,
 943                             array_element_release,
 944                             arrayprop, &local_err);
 945         if (local_err) {
 946             error_propagate(errp, local_err);
 947             return;
 948         }
 949     }
 950 }
 951
 952 PropertyInfo qdev_prop_arraylen = {
 953     .name = "uint32",
 954     .get = get_uint32,
 955     .set = set_prop_arraylen,
 956     .set_default_value = set_default_value_uint,
 957 };
 958
 959 /* --- public helpers --- */
 960
 961 static Property *qdev_prop_walk(Property *props, const char *name)
 962 {
 963     if (!props) {
 964         return NULL;
 965     }
 966     while (props->name) {
 967         if (strcmp(props->name, name) == 0) {
 968             return props;
 969         }
 970         props++;
 971     }
 972     return NULL;
 973 }
 974
 975 static Property *qdev_prop_find(DeviceState *dev, const char *name)
 976 {
 977     ObjectClass *class;
 978     Property *prop;
 979
 980     /* device properties */
 981     class = object_get_class(OBJECT(dev));
 982     do {
 983         prop = qdev_prop_walk(DEVICE_CLASS(class)->props, name);
 984         if (prop) {
 985             return prop;
 986         }
 987         class = object_class_get_parent(class);
 988     } while (class != object_class_by_name(TYPE_DEVICE));
 989
 990     return NULL;
 991 }
 992
 993 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,
 994                                     Property *prop, const char *value)
 995 {
 996     switch (ret) {
 997     case -EEXIST:
 998         error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use",
 999                   object_get_typename(OBJECT(dev)), prop->name, value);
1000         break;
1001     default:
1002     case -EINVAL:
1003         error_setg(errp, QERR_PROPERTY_VALUE_BAD,
1004                    object_get_typename(OBJECT(dev)), prop->name, value);
1005         break;
1006     case -ENOENT:
1007         error_setg(errp, "Property '%s.%s' can't find value '%s'",
1008                   object_get_typename(OBJECT(dev)), prop->name, value);
1009         break;
1010     case 0:
1011         break;
1012     }
1013 }
1014
1015 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
1016 {
1017     object_property_set_bool(OBJECT(dev), value, name, &error_abort);
1018 }
1019
1020 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
1021 {
1022     object_property_set_int(OBJECT(dev), value, name, &error_abort);
1023 }
1024
1025 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
1026 {
1027     object_property_set_int(OBJECT(dev), value, name, &error_abort);
1028 }
1029
1030 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
1031 {
1032     object_property_set_int(OBJECT(dev), value, name, &error_abort);
1033 }
1034
1035 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
1036 {
1037     object_property_set_int(OBJECT(dev), value, name, &error_abort);
1038 }
1039
1040 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
1041 {
1042     object_property_set_int(OBJECT(dev), value, name, &error_abort);
1043 }
1044
1045 void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value)
1046 {
1047     object_property_set_str(OBJECT(dev), value, name, &error_abort);
1048 }
1049
1050 void qdev_prop_set_macaddr(DeviceState *dev, const char *name,
1051                            const uint8_t *value)
1052 {
1053     char str[2 * 6 + 5 + 1];
1054     snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
1055              value[0], value[1], value[2], value[3], value[4], value[5]);
1056
1057     object_property_set_str(OBJECT(dev), str, name, &error_abort);
1058 }
1059
1060 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
1061 {
1062     Property *prop;
1063
1064     prop = qdev_prop_find(dev, name);
1065     object_property_set_str(OBJECT(dev), prop->info->enum_table[value],
1066                             name, &error_abort);
1067 }
1068
1069 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
1070 {
1071     Property *prop;
1072     void **ptr;
1073
1074     prop = qdev_prop_find(dev, name);
1075     assert(prop && prop->info == &qdev_prop_ptr);
1076     ptr = qdev_get_prop_ptr(dev, prop);
1077     *ptr = value;
1078 }
1079
1080 static GList *global_props;
1081
1082 void qdev_prop_register_global(GlobalProperty *prop)
1083 {
1084     global_props = g_list_append(global_props, prop);
1085 }
1086
1087 void register_compat_prop(const char *driver,
1088                           const char *property,
1089                           const char *value)
1090 {
1091     GlobalProperty *p = g_new0(GlobalProperty, 1);
1092
1093     /* Any compat_props must never cause error */
1094     p->errp = &error_abort;
1095     p->driver = driver;
1096     p->property = property;
1097     p->value = value;
1098     qdev_prop_register_global(p);
1099 }
1100
1101 void register_compat_props_array(GlobalProperty *prop)
1102 {
1103     for (; prop && prop->driver; prop++) {
1104         register_compat_prop(prop->driver, prop->property, prop->value);
1105     }
1106 }
1107
1108 void qdev_prop_register_global_list(GlobalProperty *props)
1109 {
1110     int i;
1111
1112     for (i = 0; props[i].driver != NULL; i++) {
1113         qdev_prop_register_global(props+i);
1114     }
1115 }
1116
1117 int qdev_prop_check_globals(void)
1118 {
1119     GList *l;
1120     int ret = 0;
1121
1122     for (l = global_props; l; l = l->next) {
1123         GlobalProperty *prop = l->data;
1124         ObjectClass *oc;
1125         DeviceClass *dc;
1126         if (prop->used) {
1127             continue;
1128         }
1129         if (!prop->user_provided) {
1130             continue;
1131         }
1132         oc = object_class_by_name(prop->driver);
1133         oc = object_class_dynamic_cast(oc, TYPE_DEVICE);
1134         if (!oc) {
1135             warn_report("global %s.%s has invalid class name",
1136                         prop->driver, prop->property);
1137             ret = 1;
1138             continue;
1139         }
1140         dc = DEVICE_CLASS(oc);
1141         if (!dc->hotpluggable && !prop->used) {
1142             warn_report("global %s.%s=%s not used",
1143                         prop->driver, prop->property, prop->value);
1144             ret = 1;
1145             continue;
1146         }
1147     }
1148     return ret;
1149 }
1150
1151 static void qdev_prop_set_globals_for_type(DeviceState *dev,
1152                                            const char *typename)
1153 {
1154     GList *l;
1155
1156     for (l = global_props; l; l = l->next) {
1157         GlobalProperty *prop = l->data;
1158         Error *err = NULL;
1159
1160         if (strcmp(typename, prop->driver) != 0) {
1161             continue;
1162         }
1163         prop->used = true;
1164         object_property_parse(OBJECT(dev), prop->value, prop->property, &err);
1165         if (err != NULL) {
1166             error_prepend(&err, "can't apply global %s.%s=%s: ",
1167                           prop->driver, prop->property, prop->value);
1168             if (!dev->hotplugged && prop->errp) {
1169                 error_propagate(prop->errp, err);
1170             } else {
1171                 assert(prop->user_provided);
1172                 error_reportf_err(err, "Warning: ");
1173             }
1174         }
1175     }
1176 }
1177
1178 void qdev_prop_set_globals(DeviceState *dev)
1179 {
1180     ObjectClass *class = object_get_class(OBJECT(dev));
1181
1182     do {
1183         qdev_prop_set_globals_for_type(dev, object_class_get_name(class));
1184         class = object_class_get_parent(class);
1185     } while (class);
1186 }
1187
1188 /* --- 64bit unsigned int 'size' type --- */
1189
1190 static void get_size(Object *obj, Visitor *v, const char *name, void *opaque,
1191                      Error **errp)
1192 {
1193     DeviceState *dev = DEVICE(obj);
1194     Property *prop = opaque;
1195     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
1196
1197     visit_type_size(v, name, ptr, errp);
1198 }
1199
1200 static void set_size(Object *obj, Visitor *v, const char *name, void *opaque,
1201                      Error **errp)
1202 {
1203     DeviceState *dev = DEVICE(obj);
1204     Property *prop = opaque;
1205     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
1206
1207     visit_type_size(v, name, ptr, errp);
1208 }
1209
1210 PropertyInfo qdev_prop_size = {
1211     .name  = "size",
1212     .get = get_size,
1213     .set = set_size,
1214     .set_default_value = set_default_value_uint,
1215 };