hw/qdev-properties.c

   1 #include "net.h"
   2 #include "qdev.h"
   3 #include "qerror.h"
   4
   5 void *qdev_get_prop_ptr(DeviceState *dev, Property *prop)
   6 {
   7     void *ptr = dev;
   8     ptr += prop->offset;
   9     return ptr;
  10 }
  11
  12 static uint32_t qdev_get_prop_mask(Property *prop)
  13 {
  14     assert(prop->info->type == PROP_TYPE_BIT);
  15     return 0x1 << prop->bitnr;
  16 }
  17
  18 static void bit_prop_set(DeviceState *dev, Property *props, bool val)
  19 {
  20     uint32_t *p = qdev_get_prop_ptr(dev, props);
  21     uint32_t mask = qdev_get_prop_mask(props);
  22     if (val)
  23         *p |= mask;
  24     else
  25         *p &= ~mask;
  26 }
  27
  28 static void qdev_prop_cpy(DeviceState *dev, Property *props, void *src)
  29 {
  30     if (props->info->type == PROP_TYPE_BIT) {
  31         bool *defval = src;
  32         bit_prop_set(dev, props, *defval);
  33     } else {
  34         char *dst = qdev_get_prop_ptr(dev, props);
  35         memcpy(dst, src, props->info->size);
  36     }
  37 }
  38
  39 /* Bit */
  40 static int parse_bit(DeviceState *dev, Property *prop, const char *str)
  41 {
  42     if (!strncasecmp(str, "on", 2))
  43         bit_prop_set(dev, prop, true);
  44     else if (!strncasecmp(str, "off", 3))
  45         bit_prop_set(dev, prop, false);
  46     else
  47         return -EINVAL;
  48     return 0;
  49 }
  50
  51 static int print_bit(DeviceState *dev, Property *prop, char *dest, size_t len)
  52 {
  53     uint8_t *p = qdev_get_prop_ptr(dev, prop);
  54     return snprintf(dest, len, (*p & qdev_get_prop_mask(prop)) ? "on" : "off");
  55 }
  56
  57 PropertyInfo qdev_prop_bit = {
  58     .name  = "on/off",
  59     .type  = PROP_TYPE_BIT,
  60     .size  = sizeof(uint32_t),
  61     .parse = parse_bit,
  62     .print = print_bit,
  63 };
  64
  65 /* --- 8bit integer --- */
  66
  67 static int parse_uint8(DeviceState *dev, Property *prop, const char *str)
  68 {
  69     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
  70     const char *fmt;
  71
  72     /* accept both hex and decimal */
  73     fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx8 : "%" PRIu8;
  74     if (sscanf(str, fmt, ptr) != 1)
  75         return -EINVAL;
  76     return 0;
  77 }
  78
  79 static int print_uint8(DeviceState *dev, Property *prop, char *dest, size_t len)
  80 {
  81     uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
  82     return snprintf(dest, len, "%" PRIu8, *ptr);
  83 }
  84
  85 PropertyInfo qdev_prop_uint8 = {
  86     .name  = "uint8",
  87     .type  = PROP_TYPE_UINT8,
  88     .size  = sizeof(uint8_t),
  89     .parse = parse_uint8,
  90     .print = print_uint8,
  91 };
  92
  93 /* --- 16bit integer --- */
  94
  95 static int parse_uint16(DeviceState *dev, Property *prop, const char *str)
  96 {
  97     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
  98     const char *fmt;
  99
 100     /* accept both hex and decimal */
 101     fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx16 : "%" PRIu16;
 102     if (sscanf(str, fmt, ptr) != 1)
 103         return -EINVAL;
 104     return 0;
 105 }
 106
 107 static int print_uint16(DeviceState *dev, Property *prop, char *dest, size_t len)
 108 {
 109     uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
 110     return snprintf(dest, len, "%" PRIu16, *ptr);
 111 }
 112
 113 PropertyInfo qdev_prop_uint16 = {
 114     .name  = "uint16",
 115     .type  = PROP_TYPE_UINT16,
 116     .size  = sizeof(uint16_t),
 117     .parse = parse_uint16,
 118     .print = print_uint16,
 119 };
 120
 121 /* --- 32bit integer --- */
 122
 123 static int parse_uint32(DeviceState *dev, Property *prop, const char *str)
 124 {
 125     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 126     const char *fmt;
 127
 128     /* accept both hex and decimal */
 129     fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx32 : "%" PRIu32;
 130     if (sscanf(str, fmt, ptr) != 1)
 131         return -EINVAL;
 132     return 0;
 133 }
 134
 135 static int print_uint32(DeviceState *dev, Property *prop, char *dest, size_t len)
 136 {
 137     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 138     return snprintf(dest, len, "%" PRIu32, *ptr);
 139 }
 140
 141 PropertyInfo qdev_prop_uint32 = {
 142     .name  = "uint32",
 143     .type  = PROP_TYPE_UINT32,
 144     .size  = sizeof(uint32_t),
 145     .parse = parse_uint32,
 146     .print = print_uint32,
 147 };
 148
 149 static int parse_int32(DeviceState *dev, Property *prop, const char *str)
 150 {
 151     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 152
 153     if (sscanf(str, "%" PRId32, ptr) != 1)
 154         return -EINVAL;
 155     return 0;
 156 }
 157
 158 static int print_int32(DeviceState *dev, Property *prop, char *dest, size_t len)
 159 {
 160     int32_t *ptr = qdev_get_prop_ptr(dev, prop);
 161     return snprintf(dest, len, "%" PRId32, *ptr);
 162 }
 163
 164 PropertyInfo qdev_prop_int32 = {
 165     .name  = "int32",
 166     .type  = PROP_TYPE_INT32,
 167     .size  = sizeof(int32_t),
 168     .parse = parse_int32,
 169     .print = print_int32,
 170 };
 171
 172 /* --- 32bit hex value --- */
 173
 174 static int parse_hex32(DeviceState *dev, Property *prop, const char *str)
 175 {
 176     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 177
 178     if (sscanf(str, "%" PRIx32, ptr) != 1)
 179         return -EINVAL;
 180     return 0;
 181 }
 182
 183 static int print_hex32(DeviceState *dev, Property *prop, char *dest, size_t len)
 184 {
 185     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 186     return snprintf(dest, len, "0x%" PRIx32, *ptr);
 187 }
 188
 189 PropertyInfo qdev_prop_hex32 = {
 190     .name  = "hex32",
 191     .type  = PROP_TYPE_UINT32,
 192     .size  = sizeof(uint32_t),
 193     .parse = parse_hex32,
 194     .print = print_hex32,
 195 };
 196
 197 /* --- 64bit integer --- */
 198
 199 static int parse_uint64(DeviceState *dev, Property *prop, const char *str)
 200 {
 201     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 202     const char *fmt;
 203
 204     /* accept both hex and decimal */
 205     fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx64 : "%" PRIu64;
 206     if (sscanf(str, fmt, ptr) != 1)
 207         return -EINVAL;
 208     return 0;
 209 }
 210
 211 static int print_uint64(DeviceState *dev, Property *prop, char *dest, size_t len)
 212 {
 213     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 214     return snprintf(dest, len, "%" PRIu64, *ptr);
 215 }
 216
 217 PropertyInfo qdev_prop_uint64 = {
 218     .name  = "uint64",
 219     .type  = PROP_TYPE_UINT64,
 220     .size  = sizeof(uint64_t),
 221     .parse = parse_uint64,
 222     .print = print_uint64,
 223 };
 224
 225 /* --- 64bit hex value --- */
 226
 227 static int parse_hex64(DeviceState *dev, Property *prop, const char *str)
 228 {
 229     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 230
 231     if (sscanf(str, "%" PRIx64, ptr) != 1)
 232         return -EINVAL;
 233     return 0;
 234 }
 235
 236 static int print_hex64(DeviceState *dev, Property *prop, char *dest, size_t len)
 237 {
 238     uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
 239     return snprintf(dest, len, "0x%" PRIx64, *ptr);
 240 }
 241
 242 PropertyInfo qdev_prop_hex64 = {
 243     .name  = "hex64",
 244     .type  = PROP_TYPE_UINT64,
 245     .size  = sizeof(uint64_t),
 246     .parse = parse_hex64,
 247     .print = print_hex64,
 248 };
 249
 250 /* --- string --- */
 251
 252 static int parse_string(DeviceState *dev, Property *prop, const char *str)
 253 {
 254     char **ptr = qdev_get_prop_ptr(dev, prop);
 255
 256     if (*ptr)
 257         qemu_free(*ptr);
 258     *ptr = qemu_strdup(str);
 259     return 0;
 260 }
 261
 262 static void free_string(DeviceState *dev, Property *prop)
 263 {
 264     qemu_free(*(char **)qdev_get_prop_ptr(dev, prop));
 265 }
 266
 267 static int print_string(DeviceState *dev, Property *prop, char *dest, size_t len)
 268 {
 269     char **ptr = qdev_get_prop_ptr(dev, prop);
 270     if (!*ptr)
 271         return snprintf(dest, len, "<null>");
 272     return snprintf(dest, len, "\"%s\"", *ptr);
 273 }
 274
 275 PropertyInfo qdev_prop_string = {
 276     .name  = "string",
 277     .type  = PROP_TYPE_STRING,
 278     .size  = sizeof(char*),
 279     .parse = parse_string,
 280     .print = print_string,
 281     .free  = free_string,
 282 };
 283
 284 /* --- drive --- */
 285
 286 static int parse_drive(DeviceState *dev, Property *prop, const char *str)
 287 {
 288     DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);
 289
 290     *ptr = drive_get_by_id(str);
 291     if (*ptr == NULL)
 292         return -ENOENT;
 293     return 0;
 294 }
 295
 296 static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len)
 297 {
 298     DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);
 299     return snprintf(dest, len, "%s", (*ptr) ? (*ptr)->id : "<null>");
 300 }
 301
 302 PropertyInfo qdev_prop_drive = {
 303     .name  = "drive",
 304     .type  = PROP_TYPE_DRIVE,
 305     .size  = sizeof(DriveInfo*),
 306     .parse = parse_drive,
 307     .print = print_drive,
 308 };
 309
 310 /* --- character device --- */
 311
 312 static int parse_chr(DeviceState *dev, Property *prop, const char *str)
 313 {
 314     CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 315
 316     *ptr = qemu_chr_find(str);
 317     if (*ptr == NULL)
 318         return -ENOENT;
 319     return 0;
 320 }
 321
 322 static int print_chr(DeviceState *dev, Property *prop, char *dest, size_t len)
 323 {
 324     CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 325
 326     if (*ptr && (*ptr)->label) {
 327         return snprintf(dest, len, "%s", (*ptr)->label);
 328     } else {
 329         return snprintf(dest, len, "<null>");
 330     }
 331 }
 332
 333 PropertyInfo qdev_prop_chr = {
 334     .name  = "chr",
 335     .type  = PROP_TYPE_CHR,
 336     .size  = sizeof(CharDriverState*),
 337     .parse = parse_chr,
 338     .print = print_chr,
 339 };
 340
 341 /* --- netdev device --- */
 342
 343 static int parse_netdev(DeviceState *dev, Property *prop, const char *str)
 344 {
 345     VLANClientState **ptr = qdev_get_prop_ptr(dev, prop);
 346
 347     *ptr = qemu_find_netdev(str);
 348     if (*ptr == NULL)
 349         return -ENOENT;
 350     if ((*ptr)->peer) {
 351         return -EEXIST;
 352     }
 353     return 0;
 354 }
 355
 356 static int print_netdev(DeviceState *dev, Property *prop, char *dest, size_t len)
 357 {
 358     VLANClientState **ptr = qdev_get_prop_ptr(dev, prop);
 359
 360     if (*ptr && (*ptr)->name) {
 361         return snprintf(dest, len, "%s", (*ptr)->name);
 362     } else {
 363         return snprintf(dest, len, "<null>");
 364     }
 365 }
 366
 367 PropertyInfo qdev_prop_netdev = {
 368     .name  = "netdev",
 369     .type  = PROP_TYPE_NETDEV,
 370     .size  = sizeof(VLANClientState*),
 371     .parse = parse_netdev,
 372     .print = print_netdev,
 373 };
 374
 375 /* --- vlan --- */
 376
 377 static int parse_vlan(DeviceState *dev, Property *prop, const char *str)
 378 {
 379     VLANState **ptr = qdev_get_prop_ptr(dev, prop);
 380     int id;
 381
 382     if (sscanf(str, "%d", &id) != 1)
 383         return -EINVAL;
 384     *ptr = qemu_find_vlan(id, 1);
 385     if (*ptr == NULL)
 386         return -ENOENT;
 387     return 0;
 388 }
 389
 390 static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len)
 391 {
 392     VLANState **ptr = qdev_get_prop_ptr(dev, prop);
 393
 394     if (*ptr) {
 395         return snprintf(dest, len, "%d", (*ptr)->id);
 396     } else {
 397         return snprintf(dest, len, "<null>");
 398     }
 399 }
 400
 401 PropertyInfo qdev_prop_vlan = {
 402     .name  = "vlan",
 403     .type  = PROP_TYPE_VLAN,
 404     .size  = sizeof(VLANClientState*),
 405     .parse = parse_vlan,
 406     .print = print_vlan,
 407 };
 408
 409 /* --- pointer --- */
 410
 411 /* Not a proper property, just for dirty hacks.  TODO Remove it!  */
 412 PropertyInfo qdev_prop_ptr = {
 413     .name  = "ptr",
 414     .type  = PROP_TYPE_PTR,
 415     .size  = sizeof(void*),
 416 };
 417
 418 /* --- mac address --- */
 419
 420 /*
 421  * accepted syntax versions:
 422  *   01:02:03:04:05:06
 423  *   01-02-03-04-05-06
 424  */
 425 static int parse_mac(DeviceState *dev, Property *prop, const char *str)
 426 {
 427     MACAddr *mac = qdev_get_prop_ptr(dev, prop);
 428     int i, pos;
 429     char *p;
 430
 431     for (i = 0, pos = 0; i < 6; i++, pos += 3) {
 432         if (!qemu_isxdigit(str[pos]))
 433             return -EINVAL;
 434         if (!qemu_isxdigit(str[pos+1]))
 435             return -EINVAL;
 436         if (i == 5) {
 437             if (str[pos+2] != '\0')
 438                 return -EINVAL;
 439         } else {
 440             if (str[pos+2] != ':' && str[pos+2] != '-')
 441                 return -EINVAL;
 442         }
 443         mac->a[i] = strtol(str+pos, &p, 16);
 444     }
 445     return 0;
 446 }
 447
 448 static int print_mac(DeviceState *dev, Property *prop, char *dest, size_t len)
 449 {
 450     MACAddr *mac = qdev_get_prop_ptr(dev, prop);
 451
 452     return snprintf(dest, len, "%02x:%02x:%02x:%02x:%02x:%02x",
 453                     mac->a[0], mac->a[1], mac->a[2],
 454                     mac->a[3], mac->a[4], mac->a[5]);
 455 }
 456
 457 PropertyInfo qdev_prop_macaddr = {
 458     .name  = "macaddr",
 459     .type  = PROP_TYPE_MACADDR,
 460     .size  = sizeof(MACAddr),
 461     .parse = parse_mac,
 462     .print = print_mac,
 463 };
 464
 465 /* --- pci address --- */
 466
 467 /*
 468  * bus-local address, i.e. "$slot" or "$slot.$fn"
 469  */
 470 static int parse_pci_devfn(DeviceState *dev, Property *prop, const char *str)
 471 {
 472     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 473     unsigned int slot, fn, n;
 474
 475     if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
 476         fn = 0;
 477         if (sscanf(str, "%x%n", &slot, &n) != 1) {
 478             return -EINVAL;
 479         }
 480     }
 481     if (str[n] != '\0')
 482         return -EINVAL;
 483     if (fn > 7)
 484         return -EINVAL;
 485     *ptr = slot << 3 | fn;
 486     return 0;
 487 }
 488
 489 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len)
 490 {
 491     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
 492
 493     if (*ptr == -1) {
 494         return snprintf(dest, len, "<unset>");
 495     } else {
 496         return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
 497     }
 498 }
 499
 500 PropertyInfo qdev_prop_pci_devfn = {
 501     .name  = "pci-devfn",
 502     .type  = PROP_TYPE_UINT32,
 503     .size  = sizeof(uint32_t),
 504     .parse = parse_pci_devfn,
 505     .print = print_pci_devfn,
 506 };
 507
 508 /* --- public helpers --- */
 509
 510 static Property *qdev_prop_walk(Property *props, const char *name)
 511 {
 512     if (!props)
 513         return NULL;
 514     while (props->name) {
 515         if (strcmp(props->name, name) == 0)
 516             return props;
 517         props++;
 518     }
 519     return NULL;
 520 }
 521
 522 static Property *qdev_prop_find(DeviceState *dev, const char *name)
 523 {
 524     Property *prop;
 525
 526     /* device properties */
 527     prop = qdev_prop_walk(dev->info->props, name);
 528     if (prop)
 529         return prop;
 530
 531     /* bus properties */
 532     prop = qdev_prop_walk(dev->parent_bus->info->props, name);
 533     if (prop)
 534         return prop;
 535
 536     return NULL;
 537 }
 538
 539 int qdev_prop_exists(DeviceState *dev, const char *name)
 540 {
 541     return qdev_prop_find(dev, name) ? true : false;
 542 }
 543
 544 int qdev_prop_parse(DeviceState *dev, const char *name, const char *value)
 545 {
 546     Property *prop;
 547     int ret;
 548
 549     prop = qdev_prop_find(dev, name);
 550     /*
 551      * TODO Properties without a parse method are just for dirty
 552      * hacks.  qdev_prop_ptr is the only such PropertyInfo.  It's
 553      * marked for removal.  The test !prop->info->parse should be
 554      * removed along with it.
 555      */
 556     if (!prop || !prop->info->parse) {
 557         qerror_report(QERR_PROPERTY_NOT_FOUND, dev->info->name, name);
 558         return -1;
 559     }
 560     ret = prop->info->parse(dev, prop, value);
 561     if (ret < 0) {
 562         switch (ret) {
 563         case -EEXIST:
 564             qerror_report(QERR_PROPERTY_VALUE_IN_USE,
 565                           dev->info->name, name, value);
 566             break;
 567         default:
 568         case -EINVAL:
 569             qerror_report(QERR_PROPERTY_VALUE_BAD,
 570                           dev->info->name, name, value);
 571             break;
 572         case -ENOENT:
 573             qerror_report(QERR_PROPERTY_VALUE_NOT_FOUND,
 574                           dev->info->name, name, value);
 575             break;
 576         }
 577         return -1;
 578     }
 579     return 0;
 580 }
 581
 582 void qdev_prop_set(DeviceState *dev, const char *name, void *src, enum PropertyType type)
 583 {
 584     Property *prop;
 585
 586     prop = qdev_prop_find(dev, name);
 587     if (!prop) {
 588         fprintf(stderr, "%s: property \"%s.%s\" not found\n",
 589                 __FUNCTION__, dev->info->name, name);
 590         abort();
 591     }
 592     if (prop->info->type != type) {
 593         fprintf(stderr, "%s: property \"%s.%s\" type mismatch\n",
 594                 __FUNCTION__, dev->info->name, name);
 595         abort();
 596     }
 597     qdev_prop_cpy(dev, prop, src);
 598 }
 599
 600 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
 601 {
 602     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT8);
 603 }
 604
 605 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
 606 {
 607     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT16);
 608 }
 609
 610 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
 611 {
 612     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT32);
 613 }
 614
 615 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
 616 {
 617     qdev_prop_set(dev, name, &value, PROP_TYPE_INT32);
 618 }
 619
 620 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
 621 {
 622     qdev_prop_set(dev, name, &value, PROP_TYPE_UINT64);
 623 }
 624
 625 void qdev_prop_set_string(DeviceState *dev, const char *name, char *value)
 626 {
 627     qdev_prop_set(dev, name, &value, PROP_TYPE_STRING);
 628 }
 629
 630 void qdev_prop_set_drive(DeviceState *dev, const char *name, DriveInfo *value)
 631 {
 632     qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE);
 633 }
 634
 635 void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value)
 636 {
 637     qdev_prop_set(dev, name, &value, PROP_TYPE_CHR);
 638 }
 639
 640 void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value)
 641 {
 642     qdev_prop_set(dev, name, &value, PROP_TYPE_NETDEV);
 643 }
 644
 645 void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value)
 646 {
 647     qdev_prop_set(dev, name, &value, PROP_TYPE_VLAN);
 648 }
 649
 650 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value)
 651 {
 652     qdev_prop_set(dev, name, value, PROP_TYPE_MACADDR);
 653 }
 654
 655 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
 656 {
 657     qdev_prop_set(dev, name, &value, PROP_TYPE_PTR);
 658 }
 659
 660 void qdev_prop_set_defaults(DeviceState *dev, Property *props)
 661 {
 662     if (!props)
 663         return;
 664     while (props->name) {
 665         if (props->defval) {
 666             qdev_prop_cpy(dev, props, props->defval);
 667         }
 668         props++;
 669     }
 670 }
 671
 672 static QTAILQ_HEAD(, GlobalProperty) global_props = QTAILQ_HEAD_INITIALIZER(global_props);
 673
 674 static void qdev_prop_register_global(GlobalProperty *prop)
 675 {
 676     QTAILQ_INSERT_TAIL(&global_props, prop, next);
 677 }
 678
 679 void qdev_prop_register_global_list(GlobalProperty *props)
 680 {
 681     int i;
 682
 683     for (i = 0; props[i].driver != NULL; i++) {
 684         qdev_prop_register_global(props+i);
 685     }
 686 }
 687
 688 void qdev_prop_set_globals(DeviceState *dev)
 689 {
 690     GlobalProperty *prop;
 691
 692     QTAILQ_FOREACH(prop, &global_props, next) {
 693         if (strcmp(dev->info->name, prop->driver) != 0 &&
 694             strcmp(dev->info->bus_info->name, prop->driver) != 0) {
 695             continue;
 696         }
 697         if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {
 698             exit(1);
 699         }
 700     }
 701 }
 702
 703 static int qdev_add_one_global(QemuOpts *opts, void *opaque)
 704 {
 705     GlobalProperty *g;
 706
 707     g = qemu_mallocz(sizeof(*g));
 708     g->driver   = qemu_opt_get(opts, "driver");
 709     g->property = qemu_opt_get(opts, "property");
 710     g->value    = qemu_opt_get(opts, "value");
 711     qdev_prop_register_global(g);
 712     return 0;
 713 }
 714
 715 void qemu_add_globals(void)
 716 {
 717     qemu_opts_foreach(&qemu_global_opts, qdev_add_one_global, NULL, 0);
 718 }