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