hw/qdev-properties.c

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