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