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