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