hw/core/qdev-properties.c

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