hw/core/qdev-properties.c

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