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