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         return set_int32(obj, v, opaque, name, errp);
 838     }
 839
 840     if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
 841         fn = 0;
 842         if (sscanf(str, "%x%n", &slot, &n) != 1) {
 843             goto invalid;
 844         }
 845     }
 846     if (str[n] != '\0' || fn > 7 || slot > 31) {
 847         goto invalid;
 848     }
 849     *ptr = slot << 3 | fn;
 850     return;
 851
 852 invalid:
 853     error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
 854 }
 855
 856 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len)
 857 {
 858     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 859
 860     if (*ptr == -1) {
 861         return snprintf(dest, len, "<unset>");
 862     } else {
 863         return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
 864     }
 865 }
 866
 867 PropertyInfo qdev_prop_pci_devfn = {
 868     .name  = "int32",
 869     .legacy_name  = "pci-devfn",
 870     .print = print_pci_devfn,
 871     .get   = get_int32,
 872     .set   = set_pci_devfn,
 873     /* FIXME: this should be -1...255, but the address is stored
 874      * into an uint32_t rather than int32_t.
 875      */
 876     .min   = 0,
 877     .max   = 0xFFFFFFFFULL,
 878 };
 879
 880 /* --- public helpers --- */
 881
 882 static Property *qdev_prop_walk(Property *props, const char *name)
 883 {
 884     if (!props)
 885         return NULL;
 886     while (props->name) {
 887         if (strcmp(props->name, name) == 0)
 888             return props;
 889         props++;
 890     }
 891     return NULL;
 892 }
 893
 894 static Property *qdev_prop_find(DeviceState *dev, const char *name)
 895 {
 896     Property *prop;
 897
 898     /* device properties */
 899     prop = qdev_prop_walk(qdev_get_props(dev), name);
 900     if (prop)
 901         return prop;
 902
 903     /* bus properties */
 904     prop = qdev_prop_walk(dev->parent_bus->info->props, name);
 905     if (prop)
 906         return prop;
 907
 908     return NULL;
 909 }
 910
 911 int qdev_prop_exists(DeviceState *dev, const char *name)
 912 {
 913     return qdev_prop_find(dev, name) ? true : false;
 914 }
 915
 916 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,
 917                                     Property *prop, const char *value)
 918 {
 919     switch (ret) {
 920     case -EEXIST:
 921         error_set(errp, QERR_PROPERTY_VALUE_IN_USE,
 922                   object_get_typename(OBJECT(dev)), prop->name, value);
 923         break;
 924     default:
 925     case -EINVAL:
 926         error_set(errp, QERR_PROPERTY_VALUE_BAD,
 927                   object_get_typename(OBJECT(dev)), prop->name, value);
 928         break;
 929     case -ENOENT:
 930         error_set(errp, QERR_PROPERTY_VALUE_NOT_FOUND,
 931                   object_get_typename(OBJECT(dev)), prop->name, value);
 932         break;
 933     case 0:
 934         break;
 935     }
 936 }
 937
 938 int qdev_prop_parse(DeviceState *dev, const char *name, const char *value)
 939 {
 940     char *legacy_name;
 941     Error *err = NULL;
 942
 943     legacy_name = g_strdup_printf("legacy-%s", name);
 944     if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
 945         object_property_parse(OBJECT(dev), value, legacy_name, &err);
 946     } else {
 947         object_property_parse(OBJECT(dev), value, name, &err);
 948     }
 949     g_free(legacy_name);
 950
 951     if (err) {
 952         qerror_report_err(err);
 953         error_free(err);
 954         return -1;
 955     }
 956     return 0;
 957 }
 958
 959 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
 960 {
 961     Error *errp = NULL;
 962     object_property_set_bool(OBJECT(dev), value, name, &errp);
 963     assert_no_error(errp);
 964 }
 965
 966 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
 967 {
 968     Error *errp = NULL;
 969     object_property_set_int(OBJECT(dev), value, name, &errp);
 970     assert_no_error(errp);
 971 }
 972
 973 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
 974 {
 975     Error *errp = NULL;
 976     object_property_set_int(OBJECT(dev), value, name, &errp);
 977     assert_no_error(errp);
 978 }
 979
 980 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
 981 {
 982     Error *errp = NULL;
 983     object_property_set_int(OBJECT(dev), value, name, &errp);
 984     assert_no_error(errp);
 985 }
 986
 987 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
 988 {
 989     Error *errp = NULL;
 990     object_property_set_int(OBJECT(dev), value, name, &errp);
 991     assert_no_error(errp);
 992 }
 993
 994 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
 995 {
 996     Error *errp = NULL;
 997     object_property_set_int(OBJECT(dev), value, name, &errp);
 998     assert_no_error(errp);
 999 }
1000
1001 void qdev_prop_set_string(DeviceState *dev, const char *name, char *value)
1002 {
1003     Error *errp = NULL;
1004     object_property_set_str(OBJECT(dev), value, name, &errp);
1005     assert_no_error(errp);
1006 }
1007
1008 int qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value)
1009 {
1010     Error *errp = NULL;
1011     const char *bdrv_name = value ? bdrv_get_device_name(value) : "";
1012     object_property_set_str(OBJECT(dev), bdrv_name,
1013                             name, &errp);
1014     if (errp) {
1015         qerror_report_err(errp);
1016         error_free(errp);
1017         return -1;
1018     }
1019     return 0;
1020 }
1021
1022 void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, BlockDriverState *value)
1023 {
1024     if (qdev_prop_set_drive(dev, name, value) < 0) {
1025         exit(1);
1026     }
1027 }
1028 void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value)
1029 {
1030     Error *errp = NULL;
1031     assert(!value || value->label);
1032     object_property_set_str(OBJECT(dev),
1033                             value ? value->label : "", name, &errp);
1034     assert_no_error(errp);
1035 }
1036
1037 void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value)
1038 {
1039     Error *errp = NULL;
1040     assert(!value || value->name);
1041     object_property_set_str(OBJECT(dev),
1042                             value ? value->name : "", name, &errp);
1043     assert_no_error(errp);
1044 }
1045
1046 void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value)
1047 {
1048     Error *errp = NULL;
1049     object_property_set_int(OBJECT(dev), value ? value->id : -1, name, &errp);
1050     assert_no_error(errp);
1051 }
1052
1053 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value)
1054 {
1055     Error *errp = NULL;
1056     char str[2 * 6 + 5 + 1];
1057     snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
1058              value[0], value[1], value[2], value[3], value[4], value[5]);
1059
1060     object_property_set_str(OBJECT(dev), str, name, &errp);
1061     assert_no_error(errp);
1062 }
1063
1064 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
1065 {
1066     Property *prop;
1067     Error *errp = NULL;
1068
1069     prop = qdev_prop_find(dev, name);
1070     object_property_set_str(OBJECT(dev), prop->info->enum_table[value],
1071                             name, &errp);
1072     assert_no_error(errp);
1073 }
1074
1075 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
1076 {
1077     Property *prop;
1078     void **ptr;
1079
1080     prop = qdev_prop_find(dev, name);
1081     assert(prop && prop->info == &qdev_prop_ptr);
1082     ptr = qdev_get_prop_ptr(dev, prop);
1083     *ptr = value;
1084 }
1085
1086 void qdev_prop_set_defaults(DeviceState *dev, Property *props)
1087 {
1088     Object *obj = OBJECT(dev);
1089     if (!props)
1090         return;
1091     for (; props->name; props++) {
1092         Error *errp = NULL;
1093         if (props->qtype == QTYPE_NONE) {
1094             continue;
1095         }
1096         if (props->qtype == QTYPE_QBOOL) {
1097             object_property_set_bool(obj, props->defval, props->name, &errp);
1098         } else if (props->info->enum_table) {
1099             object_property_set_str(obj, props->info->enum_table[props->defval],
1100                                     props->name, &errp);
1101         } else if (props->qtype == QTYPE_QINT) {
1102             object_property_set_int(obj, props->defval, props->name, &errp);
1103         }
1104         assert_no_error(errp);
1105     }
1106 }
1107
1108 static QTAILQ_HEAD(, GlobalProperty) global_props = QTAILQ_HEAD_INITIALIZER(global_props);
1109
1110 static void qdev_prop_register_global(GlobalProperty *prop)
1111 {
1112     QTAILQ_INSERT_TAIL(&global_props, prop, next);
1113 }
1114
1115 void qdev_prop_register_global_list(GlobalProperty *props)
1116 {
1117     int i;
1118
1119     for (i = 0; props[i].driver != NULL; i++) {
1120         qdev_prop_register_global(props+i);
1121     }
1122 }
1123
1124 void qdev_prop_set_globals(DeviceState *dev)
1125 {
1126     GlobalProperty *prop;
1127
1128     QTAILQ_FOREACH(prop, &global_props, next) {
1129         if (strcmp(object_get_typename(OBJECT(dev)), prop->driver) != 0 &&
1130             strcmp(qdev_get_bus_info(dev)->name, prop->driver) != 0) {
1131             continue;
1132         }
1133         if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {
1134             exit(1);
1135         }
1136     }
1137 }
1138
1139 static int qdev_add_one_global(QemuOpts *opts, void *opaque)
1140 {
1141     GlobalProperty *g;
1142
1143     g = g_malloc0(sizeof(*g));
1144     g->driver   = qemu_opt_get(opts, "driver");
1145     g->property = qemu_opt_get(opts, "property");
1146     g->value    = qemu_opt_get(opts, "value");
1147     qdev_prop_register_global(g);
1148     return 0;
1149 }
1150
1151 void qemu_add_globals(void)
1152 {
1153     qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global, NULL, 0);
1154 }