hw/qdev-properties.c

   1 #include "net.h"
   2 #include "qdev.h"
   3 #include "qerror.h"
   4 #include "blockdev.h"
   5
   6 void *qdev_get_prop_ptr(DeviceState *dev, Property *prop)
   7 {
   8     void *ptr = dev;
   9     ptr += prop->offset;
  10     return ptr;
  11 }
  12
  13 static uint32_t qdev_get_prop_mask(Property *prop)
  14 {
  15     assert(prop->info == &qdev_prop_bit);
  16     return 0x1 << prop->bitnr;
  17 }
  18
  19 static void bit_prop_set(DeviceState *dev, Property *props, bool val)
  20 {
  21     uint32_t *p = qdev_get_prop_ptr(dev, props);
  22     uint32_t mask = qdev_get_prop_mask(props);
  23     if (val)
  24         *p |= mask;
  25     else
  26         *p &= ~mask;
  27 }
  28
  29 /* Bit */
  30
  31 static int print_bit(DeviceState *dev, Property *prop, char *dest, size_t len)
  32 {
  33     uint32_t *p = qdev_get_prop_ptr(dev, prop);
  34     return snprintf(dest, len, (*p & qdev_get_prop_mask(prop)) ? "on" : "off");
  35 }
  36
  37 static void get_bit(Object *obj, Visitor *v, void *opaque,
  38                     const char *name, Error **errp)
  39 {
  40     DeviceState *dev = DEVICE(obj);
  41     Property *prop = opaque;
  42     uint32_t *p = qdev_get_prop_ptr(dev, prop);
  43     bool value = (*p & qdev_get_prop_mask(prop)) != 0;
  44
  45     visit_type_bool(v, &value, name, errp);
  46 }
  47
  48 static void set_bit(Object *obj, Visitor *v, void *opaque,
  49                     const char *name, Error **errp)
  50 {
  51     DeviceState *dev = DEVICE(obj);
  52     Property *prop = opaque;
  53     Error *local_err = NULL;
  54     bool value;
  55
  56     if (dev->state != DEV_STATE_CREATED) {
  57         error_set(errp, QERR_PERMISSION_DENIED);
  58         return;
  59     }
  60
  61     visit_type_bool(v, &value, name, &local_err);
  62     if (local_err) {
  63         error_propagate(errp, local_err);
  64         return;
  65     }
  66     bit_prop_set(dev, prop, value);
  67 }
  68
  69 PropertyInfo qdev_prop_bit = {
  70     .name  = "boolean",
  71     .legacy_name  = "on/off",
  72     .print = print_bit,
  73     .get   = get_bit,
  74     .set   = set_bit,
  75 };
  76
  77 /* --- 8bit integer --- */
  78
  79 static void get_uint8(Object *obj, Visitor *v, void *opaque,
  80                       const char *name, Error **errp)
  81 {
  82     DeviceState *dev = DEVICE(obj);
  83     Property *prop = opaque;
  84     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
  85
  86     visit_type_uint8(v, ptr, name, errp);
  87 }
  88
  89 static void set_uint8(Object *obj, Visitor *v, void *opaque,
  90                       const char *name, Error **errp)
  91 {
  92     DeviceState *dev = DEVICE(obj);
  93     Property *prop = opaque;
  94     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
  95
  96     if (dev->state != DEV_STATE_CREATED) {
  97         error_set(errp, QERR_PERMISSION_DENIED);
  98         return;
  99     }
 100
 101     visit_type_uint8(v, ptr, name, errp);
 102 }
 103
 104 PropertyInfo qdev_prop_uint8 = {
 105     .name  = "uint8",
 106     .get   = get_uint8,
 107     .set   = set_uint8,
 108 };
 109
 110 /* --- 8bit hex value --- */
 111
 112 static int parse_hex8(DeviceState *dev, Property *prop, const char *str)
 113 {
 114     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
 115     char *end;
 116
 117     if (str[0] != '0' || str[1] != 'x') {
 118         return -EINVAL;
 119     }
 120
 121     *ptr = strtoul(str, &end, 16);
 122     if ((*end != '\0') || (end == str)) {
 123         return -EINVAL;
 124     }
 125
 126     return 0;
 127 }
 128
 129 static int print_hex8(DeviceState *dev, Property *prop, char *dest, size_t len)
 130 {
 131     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
 132     return snprintf(dest, len, "0x%" PRIx8, *ptr);
 133 }
 134
 135 PropertyInfo qdev_prop_hex8 = {
 136     .name  = "uint8",
 137     .legacy_name  = "hex8",
 138     .parse = parse_hex8,
 139     .print = print_hex8,
 140     .get   = get_uint8,
 141     .set   = set_uint8,
 142 };
 143
 144 /* --- 16bit integer --- */
 145
 146 static void get_uint16(Object *obj, Visitor *v, void *opaque,
 147                        const char *name, Error **errp)
 148 {
 149     DeviceState *dev = DEVICE(obj);
 150     Property *prop = opaque;
 151     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
 152
 153     visit_type_uint16(v, ptr, name, errp);
 154 }
 155
 156 static void set_uint16(Object *obj, Visitor *v, void *opaque,
 157                        const char *name, Error **errp)
 158 {
 159     DeviceState *dev = DEVICE(obj);
 160     Property *prop = opaque;
 161     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
 162
 163     if (dev->state != DEV_STATE_CREATED) {
 164         error_set(errp, QERR_PERMISSION_DENIED);
 165         return;
 166     }
 167
 168     visit_type_uint16(v, ptr, name, errp);
 169 }
 170
 171 PropertyInfo qdev_prop_uint16 = {
 172     .name  = "uint16",
 173     .get   = get_uint16,
 174     .set   = set_uint16,
 175 };
 176
 177 /* --- 32bit integer --- */
 178
 179 static void get_uint32(Object *obj, Visitor *v, void *opaque,
 180                        const char *name, Error **errp)
 181 {
 182     DeviceState *dev = DEVICE(obj);
 183     Property *prop = opaque;
 184     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 185
 186     visit_type_uint32(v, ptr, name, errp);
 187 }
 188
 189 static void set_uint32(Object *obj, Visitor *v, void *opaque,
 190                        const char *name, Error **errp)
 191 {
 192     DeviceState *dev = DEVICE(obj);
 193     Property *prop = opaque;
 194     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 195
 196     if (dev->state != DEV_STATE_CREATED) {
 197         error_set(errp, QERR_PERMISSION_DENIED);
 198         return;
 199     }
 200
 201     visit_type_uint32(v, ptr, name, errp);
 202 }
 203
 204 static void get_int32(Object *obj, Visitor *v, void *opaque,
 205                       const char *name, Error **errp)
 206 {
 207     DeviceState *dev = DEVICE(obj);
 208     Property *prop = opaque;
 209     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 210
 211     visit_type_int32(v, ptr, name, errp);
 212 }
 213
 214 static void set_int32(Object *obj, Visitor *v, void *opaque,
 215                       const char *name, Error **errp)
 216 {
 217     DeviceState *dev = DEVICE(obj);
 218     Property *prop = opaque;
 219     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 220
 221     if (dev->state != DEV_STATE_CREATED) {
 222         error_set(errp, QERR_PERMISSION_DENIED);
 223         return;
 224     }
 225
 226     visit_type_int32(v, ptr, name, errp);
 227 }
 228
 229 PropertyInfo qdev_prop_uint32 = {
 230     .name  = "uint32",
 231     .get   = get_uint32,
 232     .set   = set_uint32,
 233 };
 234
 235 PropertyInfo qdev_prop_int32 = {
 236     .name  = "int32",
 237     .get   = get_int32,
 238     .set   = set_int32,
 239 };
 240
 241 /* --- 32bit hex value --- */
 242
 243 static int parse_hex32(DeviceState *dev, Property *prop, const char *str)
 244 {
 245     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 246     char *end;
 247
 248     if (str[0] != '0' || str[1] != 'x') {
 249         return -EINVAL;
 250     }
 251
 252     *ptr = strtoul(str, &end, 16);
 253     if ((*end != '\0') || (end == str)) {
 254         return -EINVAL;
 255     }
 256
 257     return 0;
 258 }
 259
 260 static int print_hex32(DeviceState *dev, Property *prop, char *dest, size_t len)
 261 {
 262     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 263     return snprintf(dest, len, "0x%" PRIx32, *ptr);
 264 }
 265
 266 PropertyInfo qdev_prop_hex32 = {
 267     .name  = "uint32",
 268     .legacy_name  = "hex32",
 269     .parse = parse_hex32,
 270     .print = print_hex32,
 271     .get   = get_uint32,
 272     .set   = set_uint32,
 273 };
 274
 275 /* --- 64bit integer --- */
 276
 277 static void get_uint64(Object *obj, Visitor *v, void *opaque,
 278                        const char *name, Error **errp)
 279 {
 280     DeviceState *dev = DEVICE(obj);
 281     Property *prop = opaque;
 282     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 283
 284     visit_type_uint64(v, ptr, name, errp);
 285 }
 286
 287 static void set_uint64(Object *obj, Visitor *v, void *opaque,
 288                        const char *name, Error **errp)
 289 {
 290     DeviceState *dev = DEVICE(obj);
 291     Property *prop = opaque;
 292     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 293
 294     if (dev->state != DEV_STATE_CREATED) {
 295         error_set(errp, QERR_PERMISSION_DENIED);
 296         return;
 297     }
 298
 299     visit_type_uint64(v, ptr, name, errp);
 300 }
 301
 302 PropertyInfo qdev_prop_uint64 = {
 303     .name  = "uint64",
 304     .get   = get_uint64,
 305     .set   = set_uint64,
 306 };
 307
 308 /* --- 64bit hex value --- */
 309
 310 static int parse_hex64(DeviceState *dev, Property *prop, const char *str)
 311 {
 312     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 313     char *end;
 314
 315     if (str[0] != '0' || str[1] != 'x') {
 316         return -EINVAL;
 317     }
 318
 319     *ptr = strtoull(str, &end, 16);
 320     if ((*end != '\0') || (end == str)) {
 321         return -EINVAL;
 322     }
 323
 324     return 0;
 325 }
 326
 327 static int print_hex64(DeviceState *dev, Property *prop, char *dest, size_t len)
 328 {
 329     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 330     return snprintf(dest, len, "0x%" PRIx64, *ptr);
 331 }
 332
 333 PropertyInfo qdev_prop_hex64 = {
 334     .name  = "uint64",
 335     .legacy_name  = "hex64",
 336     .parse = parse_hex64,
 337     .print = print_hex64,
 338     .get   = get_uint64,
 339     .set   = set_uint64,
 340 };
 341
 342 /* --- string --- */
 343
 344 static void release_string(Object *obj, const char *name, void *opaque)
 345 {
 346     Property *prop = opaque;
 347     g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop));
 348 }
 349
 350 static int print_string(DeviceState *dev, Property *prop, char *dest, size_t len)
 351 {
 352     char **ptr = qdev_get_prop_ptr(dev, prop);
 353     if (!*ptr)
 354         return snprintf(dest, len, "<null>");
 355     return snprintf(dest, len, "\"%s\"", *ptr);
 356 }
 357
 358 static void get_string(Object *obj, Visitor *v, void *opaque,
 359                        const char *name, Error **errp)
 360 {
 361     DeviceState *dev = DEVICE(obj);
 362     Property *prop = opaque;
 363     char **ptr = qdev_get_prop_ptr(dev, prop);
 364
 365     if (!*ptr) {
 366         char *str = (char *)"";
 367         visit_type_str(v, &str, name, errp);
 368     } else {
 369         visit_type_str(v, ptr, name, errp);
 370     }
 371 }
 372
 373 static void set_string(Object *obj, Visitor *v, void *opaque,
 374                        const char *name, Error **errp)
 375 {
 376     DeviceState *dev = DEVICE(obj);
 377     Property *prop = opaque;
 378     char **ptr = qdev_get_prop_ptr(dev, prop);
 379     Error *local_err = NULL;
 380     char *str;
 381
 382     if (dev->state != DEV_STATE_CREATED) {
 383         error_set(errp, QERR_PERMISSION_DENIED);
 384         return;
 385     }
 386
 387     visit_type_str(v, &str, name, &local_err);
 388     if (local_err) {
 389         error_propagate(errp, local_err);
 390         return;
 391     }
 392     if (*ptr) {
 393         g_free(*ptr);
 394     }
 395     *ptr = str;
 396 }
 397
 398 PropertyInfo qdev_prop_string = {
 399     .name  = "string",
 400     .print = print_string,
 401     .release = release_string,
 402     .get   = get_string,
 403     .set   = set_string,
 404 };
 405
 406 /* --- drive --- */
 407
 408 static int parse_drive(DeviceState *dev, const char *str, void **ptr)
 409 {
 410     BlockDriverState *bs;
 411
 412     bs = bdrv_find(str);
 413     if (bs == NULL)
 414         return -ENOENT;
 415     if (bdrv_attach_dev(bs, dev) < 0)
 416         return -EEXIST;
 417     *ptr = bs;
 418     return 0;
 419 }
 420
 421 static void release_drive(Object *obj, const char *name, void *opaque)
 422 {
 423     DeviceState *dev = DEVICE(obj);
 424     Property *prop = opaque;
 425     BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 426
 427     if (*ptr) {
 428         bdrv_detach_dev(*ptr, dev);
 429         blockdev_auto_del(*ptr);
 430     }
 431 }
 432
 433 static const char *print_drive(void *ptr)
 434 {
 435     return bdrv_get_device_name(ptr);
 436 }
 437
 438 static void get_pointer(Object *obj, Visitor *v, Property *prop,
 439                         const char *(*print)(void *ptr),
 440                         const char *name, Error **errp)
 441 {
 442     DeviceState *dev = DEVICE(obj);
 443     void **ptr = qdev_get_prop_ptr(dev, prop);
 444     char *p;
 445
 446     p = (char *) (*ptr ? print(*ptr) : "");
 447     visit_type_str(v, &p, name, errp);
 448 }
 449
 450 static void set_pointer(Object *obj, Visitor *v, Property *prop,
 451                         int (*parse)(DeviceState *dev, const char *str, void **ptr),
 452                         const char *name, Error **errp)
 453 {
 454     DeviceState *dev = DEVICE(obj);
 455     Error *local_err = NULL;
 456     void **ptr = qdev_get_prop_ptr(dev, prop);
 457     char *str;
 458     int ret;
 459
 460     if (dev->state != DEV_STATE_CREATED) {
 461         error_set(errp, QERR_PERMISSION_DENIED);
 462         return;
 463     }
 464
 465     visit_type_str(v, &str, name, &local_err);
 466     if (local_err) {
 467         error_propagate(errp, local_err);
 468         return;
 469     }
 470     if (!*str) {
 471         g_free(str);
 472         *ptr = NULL;
 473         return;
 474     }
 475     ret = parse(dev, str, ptr);
 476     error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
 477     g_free(str);
 478 }
 479
 480 static void get_drive(Object *obj, Visitor *v, void *opaque,
 481                       const char *name, Error **errp)
 482 {
 483     get_pointer(obj, v, opaque, print_drive, name, errp);
 484 }
 485
 486 static void set_drive(Object *obj, Visitor *v, void *opaque,
 487                       const char *name, Error **errp)
 488 {
 489     set_pointer(obj, v, opaque, parse_drive, name, errp);
 490 }
 491
 492 PropertyInfo qdev_prop_drive = {
 493     .name  = "drive",
 494     .get   = get_drive,
 495     .set   = set_drive,
 496     .release = release_drive,
 497 };
 498
 499 /* --- character device --- */
 500
 501 static int parse_chr(DeviceState *dev, const char *str, void **ptr)
 502 {
 503     CharDriverState *chr = qemu_chr_find(str);
 504     if (chr == NULL) {
 505         return -ENOENT;
 506     }
 507     if (chr->avail_connections < 1) {
 508         return -EEXIST;
 509     }
 510     *ptr = chr;
 511     --chr->avail_connections;
 512     return 0;
 513 }
 514
 515 static void release_chr(Object *obj, const char *name, void *opaque)
 516 {
 517     DeviceState *dev = DEVICE(obj);
 518     Property *prop = opaque;
 519     CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 520
 521     if (*ptr) {
 522         qemu_chr_add_handlers(*ptr, NULL, NULL, NULL, NULL);
 523     }
 524 }
 525
 526
 527 static const char *print_chr(void *ptr)
 528 {
 529     CharDriverState *chr = ptr;
 530
 531     return chr->label ? chr->label : "";
 532 }
 533
 534 static void get_chr(Object *obj, Visitor *v, void *opaque,
 535                     const char *name, Error **errp)
 536 {
 537     get_pointer(obj, v, opaque, print_chr, name, errp);
 538 }
 539
 540 static void set_chr(Object *obj, Visitor *v, void *opaque,
 541                     const char *name, Error **errp)
 542 {
 543     set_pointer(obj, v, opaque, parse_chr, name, errp);
 544 }
 545
 546 PropertyInfo qdev_prop_chr = {
 547     .name  = "chr",
 548     .get   = get_chr,
 549     .set   = set_chr,
 550     .release = release_chr,
 551 };
 552
 553 /* --- netdev device --- */
 554
 555 static int parse_netdev(DeviceState *dev, const char *str, void **ptr)
 556 {
 557     VLANClientState *netdev = qemu_find_netdev(str);
 558
 559     if (netdev == NULL) {
 560         return -ENOENT;
 561     }
 562     if (netdev->peer) {
 563         return -EEXIST;
 564     }
 565     *ptr = netdev;
 566     return 0;
 567 }
 568
 569 static const char *print_netdev(void *ptr)
 570 {
 571     VLANClientState *netdev = ptr;
 572
 573     return netdev->name ? netdev->name : "";
 574 }
 575
 576 static void get_netdev(Object *obj, Visitor *v, void *opaque,
 577                        const char *name, Error **errp)
 578 {
 579     get_pointer(obj, v, opaque, print_netdev, name, errp);
 580 }
 581
 582 static void set_netdev(Object *obj, Visitor *v, void *opaque,
 583                        const char *name, Error **errp)
 584 {
 585     set_pointer(obj, v, opaque, parse_netdev, name, errp);
 586 }
 587
 588 PropertyInfo qdev_prop_netdev = {
 589     .name  = "netdev",
 590     .get   = get_netdev,
 591     .set   = set_netdev,
 592 };
 593
 594 /* --- vlan --- */
 595
 596 static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len)
 597 {
 598     VLANState **ptr = qdev_get_prop_ptr(dev, prop);
 599
 600     if (*ptr) {
 601         return snprintf(dest, len, "%d", (*ptr)->id);
 602     } else {
 603         return snprintf(dest, len, "<null>");
 604     }
 605 }
 606
 607 static void get_vlan(Object *obj, Visitor *v, void *opaque,
 608                      const char *name, Error **errp)
 609 {
 610     DeviceState *dev = DEVICE(obj);
 611     Property *prop = opaque;
 612     VLANState **ptr = qdev_get_prop_ptr(dev, prop);
 613     int64_t id;
 614
 615     id = *ptr ? (*ptr)->id : -1;
 616     visit_type_int64(v, &id, name, errp);
 617 }
 618
 619 static void set_vlan(Object *obj, Visitor *v, void *opaque,
 620                      const char *name, Error **errp)
 621 {
 622     DeviceState *dev = DEVICE(obj);
 623     Property *prop = opaque;
 624     VLANState **ptr = qdev_get_prop_ptr(dev, prop);
 625     Error *local_err = NULL;
 626     int64_t id;
 627     VLANState *vlan;
 628
 629     if (dev->state != DEV_STATE_CREATED) {
 630         error_set(errp, QERR_PERMISSION_DENIED);
 631         return;
 632     }
 633
 634     visit_type_int64(v, &id, name, &local_err);
 635     if (local_err) {
 636         error_propagate(errp, local_err);
 637         return;
 638     }
 639     if (id == -1) {
 640         *ptr = NULL;
 641         return;
 642     }
 643     vlan = qemu_find_vlan(id, 1);
 644     if (!vlan) {
 645         error_set(errp, QERR_INVALID_PARAMETER_VALUE,
 646                   name, prop->info->name);
 647         return;
 648     }
 649     *ptr = vlan;
 650 }
 651
 652 PropertyInfo qdev_prop_vlan = {
 653     .name  = "vlan",
 654     .print = print_vlan,
 655     .get   = get_vlan,
 656     .set   = set_vlan,
 657 };
 658
 659 /* --- pointer --- */
 660
 661 /* Not a proper property, just for dirty hacks.  TODO Remove it!  */
 662 PropertyInfo qdev_prop_ptr = {
 663     .name  = "ptr",
 664 };
 665
 666 /* --- mac address --- */
 667
 668 /*
 669  * accepted syntax versions:
 670  *   01:02:03:04:05:06
 671  *   01-02-03-04-05-06
 672  */
 673 static void get_mac(Object *obj, Visitor *v, void *opaque,
 674                     const char *name, Error **errp)
 675 {
 676     DeviceState *dev = DEVICE(obj);
 677     Property *prop = opaque;
 678     MACAddr *mac = qdev_get_prop_ptr(dev, prop);
 679     char buffer[2 * 6 + 5 + 1];
 680     char *p = buffer;
 681
 682     snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
 683              mac->a[0], mac->a[1], mac->a[2],
 684              mac->a[3], mac->a[4], mac->a[5]);
 685
 686     visit_type_str(v, &p, name, errp);
 687 }
 688
 689 static void set_mac(Object *obj, Visitor *v, void *opaque,
 690                     const char *name, Error **errp)
 691 {
 692     DeviceState *dev = DEVICE(obj);
 693     Property *prop = opaque;
 694     MACAddr *mac = qdev_get_prop_ptr(dev, prop);
 695     Error *local_err = NULL;
 696     int i, pos;
 697     char *str, *p;
 698
 699     if (dev->state != DEV_STATE_CREATED) {
 700         error_set(errp, QERR_PERMISSION_DENIED);
 701         return;
 702     }
 703
 704     visit_type_str(v, &str, name, &local_err);
 705     if (local_err) {
 706         error_propagate(errp, local_err);
 707         return;
 708     }
 709
 710     for (i = 0, pos = 0; i < 6; i++, pos += 3) {
 711         if (!qemu_isxdigit(str[pos]))
 712             goto inval;
 713         if (!qemu_isxdigit(str[pos+1]))
 714             goto inval;
 715         if (i == 5) {
 716             if (str[pos+2] != '\0')
 717                 goto inval;
 718         } else {
 719             if (str[pos+2] != ':' && str[pos+2] != '-')
 720                 goto inval;
 721         }
 722         mac->a[i] = strtol(str+pos, &p, 16);
 723     }
 724     g_free(str);
 725     return;
 726
 727 inval:
 728     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
 729     g_free(str);
 730 }
 731
 732 PropertyInfo qdev_prop_macaddr = {
 733     .name  = "macaddr",
 734     .get   = get_mac,
 735     .set   = set_mac,
 736 };
 737
 738
 739 /* --- lost tick policy --- */
 740
 741 static const char *lost_tick_policy_table[LOST_TICK_MAX+1] = {
 742     [LOST_TICK_DISCARD] = "discard",
 743     [LOST_TICK_DELAY] = "delay",
 744     [LOST_TICK_MERGE] = "merge",
 745     [LOST_TICK_SLEW] = "slew",
 746     [LOST_TICK_MAX] = NULL,
 747 };
 748
 749 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int));
 750
 751 static void get_enum(Object *obj, Visitor *v, void *opaque,
 752                      const char *name, Error **errp)
 753 {
 754     DeviceState *dev = DEVICE(obj);
 755     Property *prop = opaque;
 756     int *ptr = qdev_get_prop_ptr(dev, prop);
 757
 758     visit_type_enum(v, ptr, prop->info->enum_table,
 759                     prop->info->name, prop->name, errp);
 760 }
 761
 762 static void set_enum(Object *obj, Visitor *v, void *opaque,
 763                      const char *name, Error **errp)
 764 {
 765     DeviceState *dev = DEVICE(obj);
 766     Property *prop = opaque;
 767     int *ptr = qdev_get_prop_ptr(dev, prop);
 768
 769     if (dev->state != DEV_STATE_CREATED) {
 770         error_set(errp, QERR_PERMISSION_DENIED);
 771         return;
 772     }
 773
 774     visit_type_enum(v, ptr, prop->info->enum_table,
 775                     prop->info->name, prop->name, errp);
 776 }
 777
 778 PropertyInfo qdev_prop_losttickpolicy = {
 779     .name  = "LostTickPolicy",
 780     .enum_table  = lost_tick_policy_table,
 781     .get   = get_enum,
 782     .set   = set_enum,
 783 };
 784
 785 /* --- pci address --- */
 786
 787 /*
 788  * bus-local address, i.e. "$slot" or "$slot.$fn"
 789  */
 790 static void set_pci_devfn(Object *obj, Visitor *v, void *opaque,
 791                           const char *name, Error **errp)
 792 {
 793     DeviceState *dev = DEVICE(obj);
 794     Property *prop = opaque;
 795     int32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
 796     unsigned int slot, fn, n;
 797     Error *local_err = NULL;
 798     char *str;
 799
 800     if (dev->state != DEV_STATE_CREATED) {
 801         error_set(errp, QERR_PERMISSION_DENIED);
 802         return;
 803     }
 804
 805     visit_type_str(v, &str, name, &local_err);
 806     if (local_err) {
 807         error_free(local_err);
 808         local_err = NULL;
 809         visit_type_int32(v, &value, name, &local_err);
 810         if (local_err) {
 811             error_propagate(errp, local_err);
 812         } else if (value < -1 || value > 255) {
 813             error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
 814                       "pci_devfn");
 815         } else {
 816             *ptr = value;
 817         }
 818         return;
 819     }
 820
 821     if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
 822         fn = 0;
 823         if (sscanf(str, "%x%n", &slot, &n) != 1) {
 824             goto invalid;
 825         }
 826     }
 827     if (str[n] != '\0' || fn > 7 || slot > 31) {
 828         goto invalid;
 829     }
 830     *ptr = slot << 3 | fn;
 831     g_free(str);
 832     return;
 833
 834 invalid:
 835     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
 836     g_free(str);
 837 }
 838
 839 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len)
 840 {
 841     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 842
 843     if (*ptr == -1) {
 844         return snprintf(dest, len, "<unset>");
 845     } else {
 846         return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
 847     }
 848 }
 849
 850 PropertyInfo qdev_prop_pci_devfn = {
 851     .name  = "int32",
 852     .legacy_name  = "pci-devfn",
 853     .print = print_pci_devfn,
 854     .get   = get_int32,
 855     .set   = set_pci_devfn,
 856 };
 857
 858 /* --- blocksize --- */
 859
 860 static void set_blocksize(Object *obj, Visitor *v, void *opaque,
 861                           const char *name, Error **errp)
 862 {
 863     DeviceState *dev = DEVICE(obj);
 864     Property *prop = opaque;
 865     uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop);
 866     Error *local_err = NULL;
 867     const int64_t min = 512;
 868     const int64_t max = 32768;
 869
 870     if (dev->state != DEV_STATE_CREATED) {
 871         error_set(errp, QERR_PERMISSION_DENIED);
 872         return;
 873     }
 874
 875     visit_type_uint16(v, &value, name, &local_err);
 876     if (local_err) {
 877         error_propagate(errp, local_err);
 878         return;
 879     }
 880     if (value < min || value > max) {
 881         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
 882                   dev->id?:"", name, (int64_t)value, min, max);
 883         return;
 884     }
 885
 886     /* We rely on power-of-2 blocksizes for bitmasks */
 887     if ((value & (value - 1)) != 0) {
 888         error_set(errp, QERR_PROPERTY_VALUE_NOT_POWER_OF_2,
 889                   dev->id?:"", name, (int64_t)value);
 890         return;
 891     }
 892
 893     *ptr = value;
 894 }
 895
 896 PropertyInfo qdev_prop_blocksize = {
 897     .name  = "blocksize",
 898     .get   = get_uint16,
 899     .set   = set_blocksize,
 900 };
 901
 902 /* --- public helpers --- */
 903
 904 static Property *qdev_prop_walk(Property *props, const char *name)
 905 {
 906     if (!props)
 907         return NULL;
 908     while (props->name) {
 909         if (strcmp(props->name, name) == 0)
 910             return props;
 911         props++;
 912     }
 913     return NULL;
 914 }
 915
 916 static Property *qdev_prop_find(DeviceState *dev, const char *name)
 917 {
 918     Property *prop;
 919
 920     /* device properties */
 921     prop = qdev_prop_walk(qdev_get_props(dev), name);
 922     if (prop)
 923         return prop;
 924
 925     /* bus properties */
 926     prop = qdev_prop_walk(dev->parent_bus->info->props, name);
 927     if (prop)
 928         return prop;
 929
 930     return NULL;
 931 }
 932
 933 int qdev_prop_exists(DeviceState *dev, const char *name)
 934 {
 935     return qdev_prop_find(dev, name) ? true : false;
 936 }
 937
 938 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,
 939                                     Property *prop, const char *value)
 940 {
 941     switch (ret) {
 942     case -EEXIST:
 943         error_set(errp, QERR_PROPERTY_VALUE_IN_USE,
 944                   object_get_typename(OBJECT(dev)), prop->name, value);
 945         break;
 946     default:
 947     case -EINVAL:
 948         error_set(errp, QERR_PROPERTY_VALUE_BAD,
 949                   object_get_typename(OBJECT(dev)), prop->name, value);
 950         break;
 951     case -ENOENT:
 952         error_set(errp, QERR_PROPERTY_VALUE_NOT_FOUND,
 953                   object_get_typename(OBJECT(dev)), prop->name, value);
 954         break;
 955     case 0:
 956         break;
 957     }
 958 }
 959
 960 int qdev_prop_parse(DeviceState *dev, const char *name, const char *value)
 961 {
 962     char *legacy_name;
 963     Error *err = NULL;
 964
 965     legacy_name = g_strdup_printf("legacy-%s", name);
 966     if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
 967         object_property_parse(OBJECT(dev), value, legacy_name, &err);
 968     } else {
 969         object_property_parse(OBJECT(dev), value, name, &err);
 970     }
 971     g_free(legacy_name);
 972
 973     if (err) {
 974         qerror_report_err(err);
 975         error_free(err);
 976         return -1;
 977     }
 978     return 0;
 979 }
 980
 981 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
 982 {
 983     Error *errp = NULL;
 984     object_property_set_bool(OBJECT(dev), value, name, &errp);
 985     assert_no_error(errp);
 986 }
 987
 988 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
 989 {
 990     Error *errp = NULL;
 991     object_property_set_int(OBJECT(dev), value, name, &errp);
 992     assert_no_error(errp);
 993 }
 994
 995 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
 996 {
 997     Error *errp = NULL;
 998     object_property_set_int(OBJECT(dev), value, name, &errp);
 999     assert_no_error(errp);
1000 }
1001
1002 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
1003 {
1004     Error *errp = NULL;
1005     object_property_set_int(OBJECT(dev), value, name, &errp);
1006     assert_no_error(errp);
1007 }
1008
1009 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
1010 {
1011     Error *errp = NULL;
1012     object_property_set_int(OBJECT(dev), value, name, &errp);
1013     assert_no_error(errp);
1014 }
1015
1016 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
1017 {
1018     Error *errp = NULL;
1019     object_property_set_int(OBJECT(dev), value, name, &errp);
1020     assert_no_error(errp);
1021 }
1022
1023 void qdev_prop_set_string(DeviceState *dev, const char *name, char *value)
1024 {
1025     Error *errp = NULL;
1026     object_property_set_str(OBJECT(dev), value, name, &errp);
1027     assert_no_error(errp);
1028 }
1029
1030 int qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value)
1031 {
1032     Error *errp = NULL;
1033     const char *bdrv_name = value ? bdrv_get_device_name(value) : "";
1034     object_property_set_str(OBJECT(dev), bdrv_name,
1035                             name, &errp);
1036     if (errp) {
1037         qerror_report_err(errp);
1038         error_free(errp);
1039         return -1;
1040     }
1041     return 0;
1042 }
1043
1044 void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, BlockDriverState *value)
1045 {
1046     if (qdev_prop_set_drive(dev, name, value) < 0) {
1047         exit(1);
1048     }
1049 }
1050 void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value)
1051 {
1052     Error *errp = NULL;
1053     assert(!value || value->label);
1054     object_property_set_str(OBJECT(dev),
1055                             value ? value->label : "", name, &errp);
1056     assert_no_error(errp);
1057 }
1058
1059 void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value)
1060 {
1061     Error *errp = NULL;
1062     assert(!value || value->name);
1063     object_property_set_str(OBJECT(dev),
1064                             value ? value->name : "", name, &errp);
1065     assert_no_error(errp);
1066 }
1067
1068 void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value)
1069 {
1070     Error *errp = NULL;
1071     object_property_set_int(OBJECT(dev), value ? value->id : -1, name, &errp);
1072     assert_no_error(errp);
1073 }
1074
1075 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value)
1076 {
1077     Error *errp = NULL;
1078     char str[2 * 6 + 5 + 1];
1079     snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
1080              value[0], value[1], value[2], value[3], value[4], value[5]);
1081
1082     object_property_set_str(OBJECT(dev), str, name, &errp);
1083     assert_no_error(errp);
1084 }
1085
1086 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
1087 {
1088     Property *prop;
1089     Error *errp = NULL;
1090
1091     prop = qdev_prop_find(dev, name);
1092     object_property_set_str(OBJECT(dev), prop->info->enum_table[value],
1093                             name, &errp);
1094     assert_no_error(errp);
1095 }
1096
1097 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
1098 {
1099     Property *prop;
1100     void **ptr;
1101
1102     prop = qdev_prop_find(dev, name);
1103     assert(prop && prop->info == &qdev_prop_ptr);
1104     ptr = qdev_get_prop_ptr(dev, prop);
1105     *ptr = value;
1106 }
1107
1108 void qdev_prop_set_defaults(DeviceState *dev, Property *props)
1109 {
1110     Object *obj = OBJECT(dev);
1111     if (!props)
1112         return;
1113     for (; props->name; props++) {
1114         Error *errp = NULL;
1115         if (props->qtype == QTYPE_NONE) {
1116             continue;
1117         }
1118         if (props->qtype == QTYPE_QBOOL) {
1119             object_property_set_bool(obj, props->defval, props->name, &errp);
1120         } else if (props->info->enum_table) {
1121             object_property_set_str(obj, props->info->enum_table[props->defval],
1122                                     props->name, &errp);
1123         } else if (props->qtype == QTYPE_QINT) {
1124             object_property_set_int(obj, props->defval, props->name, &errp);
1125         }
1126         assert_no_error(errp);
1127     }
1128 }
1129
1130 static QTAILQ_HEAD(, GlobalProperty) global_props = QTAILQ_HEAD_INITIALIZER(global_props);
1131
1132 static void qdev_prop_register_global(GlobalProperty *prop)
1133 {
1134     QTAILQ_INSERT_TAIL(&global_props, prop, next);
1135 }
1136
1137 void qdev_prop_register_global_list(GlobalProperty *props)
1138 {
1139     int i;
1140
1141     for (i = 0; props[i].driver != NULL; i++) {
1142         qdev_prop_register_global(props+i);
1143     }
1144 }
1145
1146 void qdev_prop_set_globals(DeviceState *dev)
1147 {
1148     GlobalProperty *prop;
1149
1150     QTAILQ_FOREACH(prop, &global_props, next) {
1151         if (strcmp(object_get_typename(OBJECT(dev)), prop->driver) != 0 &&
1152             strcmp(qdev_get_bus_info(dev)->name, prop->driver) != 0) {
1153             continue;
1154         }
1155         if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {
1156             exit(1);
1157         }
1158     }
1159 }
1160
1161 static int qdev_add_one_global(QemuOpts *opts, void *opaque)
1162 {
1163     GlobalProperty *g;
1164
1165     g = g_malloc0(sizeof(*g));
1166     g->driver   = qemu_opt_get(opts, "driver");
1167     g->property = qemu_opt_get(opts, "property");
1168     g->value    = qemu_opt_get(opts, "value");
1169     qdev_prop_register_global(g);
1170     return 0;
1171 }
1172
1173 void qemu_add_globals(void)
1174 {
1175     qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global, NULL, 0);
1176 }