qom/object.c

   1 /*
   2  * QEMU Object Model
   3  *
   4  * Copyright IBM, Corp. 2011
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/object.h"
  14 #include "qemu-common.h"
  15 #include "qapi/qapi-visit-core.h"
  16 #include "qapi/string-input-visitor.h"
  17 #include "qapi/string-output-visitor.h"
  18
  19 /* TODO: replace QObject with a simpler visitor to avoid a dependency
  20  * of the QOM core on QObject?  */
  21 #include "qemu/qom-qobject.h"
  22 #include "qobject.h"
  23 #include "qbool.h"
  24 #include "qint.h"
  25 #include "qstring.h"
  26
  27 #define MAX_INTERFACES 32
  28
  29 typedef struct InterfaceImpl InterfaceImpl;
  30 typedef struct TypeImpl TypeImpl;
  31
  32 struct InterfaceImpl
  33 {
  34     const char *typename;
  35 };
  36
  37 struct TypeImpl
  38 {
  39     const char *name;
  40
  41     size_t class_size;
  42
  43     size_t instance_size;
  44
  45     void (*class_init)(ObjectClass *klass, void *data);
  46     void (*class_base_init)(ObjectClass *klass, void *data);
  47     void (*class_finalize)(ObjectClass *klass, void *data);
  48
  49     void *class_data;
  50
  51     void (*instance_init)(Object *obj);
  52     void (*instance_finalize)(Object *obj);
  53
  54     bool abstract;
  55
  56     const char *parent;
  57     TypeImpl *parent_type;
  58
  59     ObjectClass *class;
  60
  61     int num_interfaces;
  62     InterfaceImpl interfaces[MAX_INTERFACES];
  63 };
  64
  65 static Type type_interface;
  66
  67 static GHashTable *type_table_get(void)
  68 {
  69     static GHashTable *type_table;
  70
  71     if (type_table == NULL) {
  72         type_table = g_hash_table_new(g_str_hash, g_str_equal);
  73     }
  74
  75     return type_table;
  76 }
  77
  78 static void type_table_add(TypeImpl *ti)
  79 {
  80     g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
  81 }
  82
  83 static TypeImpl *type_table_lookup(const char *name)
  84 {
  85     return g_hash_table_lookup(type_table_get(), name);
  86 }
  87
  88 static TypeImpl *type_register_internal(const TypeInfo *info)
  89 {
  90     TypeImpl *ti = g_malloc0(sizeof(*ti));
  91     int i;
  92
  93     g_assert(info->name != NULL);
  94
  95     if (type_table_lookup(info->name) != NULL) {
  96         fprintf(stderr, "Registering `%s' which already exists\n", info->name);
  97         abort();
  98     }
  99
 100     ti->name = g_strdup(info->name);
 101     ti->parent = g_strdup(info->parent);
 102
 103     ti->class_size = info->class_size;
 104     ti->instance_size = info->instance_size;
 105
 106     ti->class_init = info->class_init;
 107     ti->class_base_init = info->class_base_init;
 108     ti->class_finalize = info->class_finalize;
 109     ti->class_data = info->class_data;
 110
 111     ti->instance_init = info->instance_init;
 112     ti->instance_finalize = info->instance_finalize;
 113
 114     ti->abstract = info->abstract;
 115
 116     for (i = 0; info->interfaces && info->interfaces[i].type; i++) {
 117         ti->interfaces[i].typename = g_strdup(info->interfaces[i].type);
 118     }
 119     ti->num_interfaces = i;
 120
 121     type_table_add(ti);
 122
 123     return ti;
 124 }
 125
 126 TypeImpl *type_register(const TypeInfo *info)
 127 {
 128     assert(info->parent);
 129     return type_register_internal(info);
 130 }
 131
 132 TypeImpl *type_register_static(const TypeInfo *info)
 133 {
 134     return type_register(info);
 135 }
 136
 137 static TypeImpl *type_get_by_name(const char *name)
 138 {
 139     if (name == NULL) {
 140         return NULL;
 141     }
 142
 143     return type_table_lookup(name);
 144 }
 145
 146 static TypeImpl *type_get_parent(TypeImpl *type)
 147 {
 148     if (!type->parent_type && type->parent) {
 149         type->parent_type = type_get_by_name(type->parent);
 150         g_assert(type->parent_type != NULL);
 151     }
 152
 153     return type->parent_type;
 154 }
 155
 156 static bool type_has_parent(TypeImpl *type)
 157 {
 158     return (type->parent != NULL);
 159 }
 160
 161 static size_t type_class_get_size(TypeImpl *ti)
 162 {
 163     if (ti->class_size) {
 164         return ti->class_size;
 165     }
 166
 167     if (type_has_parent(ti)) {
 168         return type_class_get_size(type_get_parent(ti));
 169     }
 170
 171     return sizeof(ObjectClass);
 172 }
 173
 174 static size_t type_object_get_size(TypeImpl *ti)
 175 {
 176     if (ti->instance_size) {
 177         return ti->instance_size;
 178     }
 179
 180     if (type_has_parent(ti)) {
 181         return type_object_get_size(type_get_parent(ti));
 182     }
 183
 184     return 0;
 185 }
 186
 187 static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type)
 188 {
 189     assert(target_type);
 190
 191     /* Check if typename is a direct ancestor of type */
 192     while (type) {
 193         if (type == target_type) {
 194             return true;
 195         }
 196
 197         type = type_get_parent(type);
 198     }
 199
 200     return false;
 201 }
 202
 203 static void type_initialize(TypeImpl *ti);
 204
 205 static void type_initialize_interface(TypeImpl *ti, const char *parent)
 206 {
 207     InterfaceClass *new_iface;
 208     TypeInfo info = { };
 209     TypeImpl *iface_impl;
 210
 211     info.parent = parent;
 212     info.name = g_strdup_printf("%s::%s", ti->name, info.parent);
 213     info.abstract = true;
 214
 215     iface_impl = type_register(&info);
 216     type_initialize(iface_impl);
 217     g_free((char *)info.name);
 218
 219     new_iface = (InterfaceClass *)iface_impl->class;
 220     new_iface->concrete_class = ti->class;
 221
 222     ti->class->interfaces = g_slist_append(ti->class->interfaces,
 223                                            iface_impl->class);
 224 }
 225
 226 static void type_initialize(TypeImpl *ti)
 227 {
 228     TypeImpl *parent;
 229
 230     if (ti->class) {
 231         return;
 232     }
 233
 234     ti->class_size = type_class_get_size(ti);
 235     ti->instance_size = type_object_get_size(ti);
 236
 237     ti->class = g_malloc0(ti->class_size);
 238
 239     parent = type_get_parent(ti);
 240     if (parent) {
 241         type_initialize(parent);
 242         GSList *e;
 243         int i;
 244
 245         g_assert(parent->class_size <= ti->class_size);
 246         memcpy(ti->class, parent->class, parent->class_size);
 247
 248         for (e = parent->class->interfaces; e; e = e->next) {
 249             ObjectClass *iface = e->data;
 250             type_initialize_interface(ti, object_class_get_name(iface));
 251         }
 252
 253         for (i = 0; i < ti->num_interfaces; i++) {
 254             TypeImpl *t = type_get_by_name(ti->interfaces[i].typename);
 255             for (e = ti->class->interfaces; e; e = e->next) {
 256                 TypeImpl *target_type = OBJECT_CLASS(e->data)->type;
 257
 258                 if (type_is_ancestor(target_type, t)) {
 259                     break;
 260                 }
 261             }
 262
 263             if (e) {
 264                 continue;
 265             }
 266
 267             type_initialize_interface(ti, ti->interfaces[i].typename);
 268         }
 269     }
 270
 271     ti->class->type = ti;
 272
 273     while (parent) {
 274         if (parent->class_base_init) {
 275             parent->class_base_init(ti->class, ti->class_data);
 276         }
 277         parent = type_get_parent(parent);
 278     }
 279
 280     if (ti->class_init) {
 281         ti->class_init(ti->class, ti->class_data);
 282     }
 283
 284
 285 }
 286
 287 static void object_init_with_type(Object *obj, TypeImpl *ti)
 288 {
 289     if (type_has_parent(ti)) {
 290         object_init_with_type(obj, type_get_parent(ti));
 291     }
 292
 293     if (ti->instance_init) {
 294         ti->instance_init(obj);
 295     }
 296 }
 297
 298 void object_initialize_with_type(void *data, TypeImpl *type)
 299 {
 300     Object *obj = data;
 301
 302     g_assert(type != NULL);
 303     type_initialize(type);
 304
 305     g_assert(type->instance_size >= sizeof(Object));
 306     g_assert(type->abstract == false);
 307
 308     memset(obj, 0, type->instance_size);
 309     obj->class = type->class;
 310     object_ref(obj);
 311     QTAILQ_INIT(&obj->properties);
 312     object_init_with_type(obj, type);
 313 }
 314
 315 void object_initialize(void *data, const char *typename)
 316 {
 317     TypeImpl *type = type_get_by_name(typename);
 318
 319     object_initialize_with_type(data, type);
 320 }
 321
 322 static inline bool object_property_is_child(ObjectProperty *prop)
 323 {
 324     return strstart(prop->type, "child<", NULL);
 325 }
 326
 327 static inline bool object_property_is_link(ObjectProperty *prop)
 328 {
 329     return strstart(prop->type, "link<", NULL);
 330 }
 331
 332 static void object_property_del_all(Object *obj)
 333 {
 334     while (!QTAILQ_EMPTY(&obj->properties)) {
 335         ObjectProperty *prop = QTAILQ_FIRST(&obj->properties);
 336
 337         QTAILQ_REMOVE(&obj->properties, prop, node);
 338
 339         if (prop->release) {
 340             prop->release(obj, prop->name, prop->opaque);
 341         }
 342
 343         g_free(prop->name);
 344         g_free(prop->type);
 345         g_free(prop);
 346     }
 347 }
 348
 349 static void object_property_del_child(Object *obj, Object *child, Error **errp)
 350 {
 351     ObjectProperty *prop;
 352
 353     QTAILQ_FOREACH(prop, &obj->properties, node) {
 354         if (object_property_is_child(prop) && prop->opaque == child) {
 355             object_property_del(obj, prop->name, errp);
 356             break;
 357         }
 358     }
 359 }
 360
 361 void object_unparent(Object *obj)
 362 {
 363     if (obj->parent) {
 364         object_property_del_child(obj->parent, obj, NULL);
 365     }
 366     if (obj->class->unparent) {
 367         (obj->class->unparent)(obj);
 368     }
 369 }
 370
 371 static void object_deinit(Object *obj, TypeImpl *type)
 372 {
 373     if (type->instance_finalize) {
 374         type->instance_finalize(obj);
 375     }
 376
 377     if (type_has_parent(type)) {
 378         object_deinit(obj, type_get_parent(type));
 379     }
 380 }
 381
 382 static void object_finalize(void *data)
 383 {
 384     Object *obj = data;
 385     TypeImpl *ti = obj->class->type;
 386
 387     object_deinit(obj, ti);
 388     object_property_del_all(obj);
 389
 390     g_assert(obj->ref == 0);
 391     if (obj->free) {
 392         obj->free(obj);
 393     }
 394 }
 395
 396 Object *object_new_with_type(Type type)
 397 {
 398     Object *obj;
 399
 400     g_assert(type != NULL);
 401     type_initialize(type);
 402
 403     obj = g_malloc(type->instance_size);
 404     object_initialize_with_type(obj, type);
 405     obj->free = g_free;
 406
 407     return obj;
 408 }
 409
 410 Object *object_new(const char *typename)
 411 {
 412     TypeImpl *ti = type_get_by_name(typename);
 413
 414     return object_new_with_type(ti);
 415 }
 416
 417 void object_delete(Object *obj)
 418 {
 419     object_unparent(obj);
 420     g_assert(obj->ref == 1);
 421     object_unref(obj);
 422 }
 423
 424 Object *object_dynamic_cast(Object *obj, const char *typename)
 425 {
 426     if (obj && object_class_dynamic_cast(object_get_class(obj), typename)) {
 427         return obj;
 428     }
 429
 430     return NULL;
 431 }
 432
 433 Object *object_dynamic_cast_assert(Object *obj, const char *typename)
 434 {
 435     Object *inst;
 436
 437     inst = object_dynamic_cast(obj, typename);
 438
 439     if (!inst && obj) {
 440         fprintf(stderr, "Object %p is not an instance of type %s\n",
 441                 obj, typename);
 442         abort();
 443     }
 444
 445     return inst;
 446 }
 447
 448 ObjectClass *object_class_dynamic_cast(ObjectClass *class,
 449                                        const char *typename)
 450 {
 451     TypeImpl *target_type = type_get_by_name(typename);
 452     TypeImpl *type = class->type;
 453     ObjectClass *ret = NULL;
 454
 455     if (type->num_interfaces && type_is_ancestor(target_type, type_interface)) {
 456         int found = 0;
 457         GSList *i;
 458
 459         for (i = class->interfaces; i; i = i->next) {
 460             ObjectClass *target_class = i->data;
 461
 462             if (type_is_ancestor(target_class->type, target_type)) {
 463                 ret = target_class;
 464                 found++;
 465             }
 466          }
 467
 468         /* The match was ambiguous, don't allow a cast */
 469         if (found > 1) {
 470             ret = NULL;
 471         }
 472     } else if (type_is_ancestor(type, target_type)) {
 473         ret = class;
 474     }
 475
 476     return ret;
 477 }
 478
 479 ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class,
 480                                               const char *typename)
 481 {
 482     ObjectClass *ret = object_class_dynamic_cast(class, typename);
 483
 484     if (!ret) {
 485         fprintf(stderr, "Object %p is not an instance of type %s\n",
 486                 class, typename);
 487         abort();
 488     }
 489
 490     return ret;
 491 }
 492
 493 const char *object_get_typename(Object *obj)
 494 {
 495     return obj->class->type->name;
 496 }
 497
 498 ObjectClass *object_get_class(Object *obj)
 499 {
 500     return obj->class;
 501 }
 502
 503 const char *object_class_get_name(ObjectClass *klass)
 504 {
 505     return klass->type->name;
 506 }
 507
 508 ObjectClass *object_class_by_name(const char *typename)
 509 {
 510     TypeImpl *type = type_get_by_name(typename);
 511
 512     if (!type) {
 513         return NULL;
 514     }
 515
 516     type_initialize(type);
 517
 518     return type->class;
 519 }
 520
 521 ObjectClass *object_class_get_parent(ObjectClass *class)
 522 {
 523     TypeImpl *type = type_get_parent(class->type);
 524
 525     if (!type) {
 526         return NULL;
 527     }
 528
 529     type_initialize(type);
 530
 531     return type->class;
 532 }
 533
 534 typedef struct OCFData
 535 {
 536     void (*fn)(ObjectClass *klass, void *opaque);
 537     const char *implements_type;
 538     bool include_abstract;
 539     void *opaque;
 540 } OCFData;
 541
 542 static void object_class_foreach_tramp(gpointer key, gpointer value,
 543                                        gpointer opaque)
 544 {
 545     OCFData *data = opaque;
 546     TypeImpl *type = value;
 547     ObjectClass *k;
 548
 549     type_initialize(type);
 550     k = type->class;
 551
 552     if (!data->include_abstract && type->abstract) {
 553         return;
 554     }
 555
 556     if (data->implements_type &&
 557         !object_class_dynamic_cast(k, data->implements_type)) {
 558         return;
 559     }
 560
 561     data->fn(k, data->opaque);
 562 }
 563
 564 void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
 565                           const char *implements_type, bool include_abstract,
 566                           void *opaque)
 567 {
 568     OCFData data = { fn, implements_type, include_abstract, opaque };
 569
 570     g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data);
 571 }
 572
 573 int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
 574                          void *opaque)
 575 {
 576     ObjectProperty *prop;
 577     int ret = 0;
 578
 579     QTAILQ_FOREACH(prop, &obj->properties, node) {
 580         if (object_property_is_child(prop)) {
 581             ret = fn(prop->opaque, opaque);
 582             if (ret != 0) {
 583                 break;
 584             }
 585         }
 586     }
 587     return ret;
 588 }
 589
 590 static void object_class_get_list_tramp(ObjectClass *klass, void *opaque)
 591 {
 592     GSList **list = opaque;
 593
 594     *list = g_slist_prepend(*list, klass);
 595 }
 596
 597 GSList *object_class_get_list(const char *implements_type,
 598                               bool include_abstract)
 599 {
 600     GSList *list = NULL;
 601
 602     object_class_foreach(object_class_get_list_tramp,
 603                          implements_type, include_abstract, &list);
 604     return list;
 605 }
 606
 607 void object_ref(Object *obj)
 608 {
 609     obj->ref++;
 610 }
 611
 612 void object_unref(Object *obj)
 613 {
 614     g_assert(obj->ref > 0);
 615     obj->ref--;
 616
 617     /* parent always holds a reference to its children */
 618     if (obj->ref == 0) {
 619         object_finalize(obj);
 620     }
 621 }
 622
 623 void object_property_add(Object *obj, const char *name, const char *type,
 624                          ObjectPropertyAccessor *get,
 625                          ObjectPropertyAccessor *set,
 626                          ObjectPropertyRelease *release,
 627                          void *opaque, Error **errp)
 628 {
 629     ObjectProperty *prop = g_malloc0(sizeof(*prop));
 630
 631     prop->name = g_strdup(name);
 632     prop->type = g_strdup(type);
 633
 634     prop->get = get;
 635     prop->set = set;
 636     prop->release = release;
 637     prop->opaque = opaque;
 638
 639     QTAILQ_INSERT_TAIL(&obj->properties, prop, node);
 640 }
 641
 642 ObjectProperty *object_property_find(Object *obj, const char *name,
 643                                      Error **errp)
 644 {
 645     ObjectProperty *prop;
 646
 647     QTAILQ_FOREACH(prop, &obj->properties, node) {
 648         if (strcmp(prop->name, name) == 0) {
 649             return prop;
 650         }
 651     }
 652
 653     error_set(errp, QERR_PROPERTY_NOT_FOUND, "", name);
 654     return NULL;
 655 }
 656
 657 void object_property_del(Object *obj, const char *name, Error **errp)
 658 {
 659     ObjectProperty *prop = object_property_find(obj, name, errp);
 660     if (prop == NULL) {
 661         return;
 662     }
 663
 664     if (prop->release) {
 665         prop->release(obj, name, prop->opaque);
 666     }
 667
 668     QTAILQ_REMOVE(&obj->properties, prop, node);
 669
 670     g_free(prop->name);
 671     g_free(prop->type);
 672     g_free(prop);
 673 }
 674
 675 void object_property_get(Object *obj, Visitor *v, const char *name,
 676                          Error **errp)
 677 {
 678     ObjectProperty *prop = object_property_find(obj, name, errp);
 679     if (prop == NULL) {
 680         return;
 681     }
 682
 683     if (!prop->get) {
 684         error_set(errp, QERR_PERMISSION_DENIED);
 685     } else {
 686         prop->get(obj, v, prop->opaque, name, errp);
 687     }
 688 }
 689
 690 void object_property_set(Object *obj, Visitor *v, const char *name,
 691                          Error **errp)
 692 {
 693     ObjectProperty *prop = object_property_find(obj, name, errp);
 694     if (prop == NULL) {
 695         return;
 696     }
 697
 698     if (!prop->set) {
 699         error_set(errp, QERR_PERMISSION_DENIED);
 700     } else {
 701         prop->set(obj, v, prop->opaque, name, errp);
 702     }
 703 }
 704
 705 void object_property_set_str(Object *obj, const char *value,
 706                              const char *name, Error **errp)
 707 {
 708     QString *qstr = qstring_from_str(value);
 709     object_property_set_qobject(obj, QOBJECT(qstr), name, errp);
 710
 711     QDECREF(qstr);
 712 }
 713
 714 char *object_property_get_str(Object *obj, const char *name,
 715                               Error **errp)
 716 {
 717     QObject *ret = object_property_get_qobject(obj, name, errp);
 718     QString *qstring;
 719     char *retval;
 720
 721     if (!ret) {
 722         return NULL;
 723     }
 724     qstring = qobject_to_qstring(ret);
 725     if (!qstring) {
 726         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
 727         retval = NULL;
 728     } else {
 729         retval = g_strdup(qstring_get_str(qstring));
 730     }
 731
 732     QDECREF(qstring);
 733     return retval;
 734 }
 735
 736 void object_property_set_link(Object *obj, Object *value,
 737                               const char *name, Error **errp)
 738 {
 739     object_property_set_str(obj, object_get_canonical_path(value),
 740                             name, errp);
 741 }
 742
 743 Object *object_property_get_link(Object *obj, const char *name,
 744                                  Error **errp)
 745 {
 746     char *str = object_property_get_str(obj, name, errp);
 747     Object *target = NULL;
 748
 749     if (str && *str) {
 750         target = object_resolve_path(str, NULL);
 751         if (!target) {
 752             error_set(errp, QERR_DEVICE_NOT_FOUND, str);
 753         }
 754     }
 755
 756     g_free(str);
 757     return target;
 758 }
 759
 760 void object_property_set_bool(Object *obj, bool value,
 761                               const char *name, Error **errp)
 762 {
 763     QBool *qbool = qbool_from_int(value);
 764     object_property_set_qobject(obj, QOBJECT(qbool), name, errp);
 765
 766     QDECREF(qbool);
 767 }
 768
 769 bool object_property_get_bool(Object *obj, const char *name,
 770                               Error **errp)
 771 {
 772     QObject *ret = object_property_get_qobject(obj, name, errp);
 773     QBool *qbool;
 774     bool retval;
 775
 776     if (!ret) {
 777         return false;
 778     }
 779     qbool = qobject_to_qbool(ret);
 780     if (!qbool) {
 781         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean");
 782         retval = false;
 783     } else {
 784         retval = qbool_get_int(qbool);
 785     }
 786
 787     QDECREF(qbool);
 788     return retval;
 789 }
 790
 791 void object_property_set_int(Object *obj, int64_t value,
 792                              const char *name, Error **errp)
 793 {
 794     QInt *qint = qint_from_int(value);
 795     object_property_set_qobject(obj, QOBJECT(qint), name, errp);
 796
 797     QDECREF(qint);
 798 }
 799
 800 int64_t object_property_get_int(Object *obj, const char *name,
 801                                 Error **errp)
 802 {
 803     QObject *ret = object_property_get_qobject(obj, name, errp);
 804     QInt *qint;
 805     int64_t retval;
 806
 807     if (!ret) {
 808         return -1;
 809     }
 810     qint = qobject_to_qint(ret);
 811     if (!qint) {
 812         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "int");
 813         retval = -1;
 814     } else {
 815         retval = qint_get_int(qint);
 816     }
 817
 818     QDECREF(qint);
 819     return retval;
 820 }
 821
 822 void object_property_parse(Object *obj, const char *string,
 823                            const char *name, Error **errp)
 824 {
 825     StringInputVisitor *mi;
 826     mi = string_input_visitor_new(string);
 827     object_property_set(obj, string_input_get_visitor(mi), name, errp);
 828
 829     string_input_visitor_cleanup(mi);
 830 }
 831
 832 char *object_property_print(Object *obj, const char *name,
 833                             Error **errp)
 834 {
 835     StringOutputVisitor *mo;
 836     char *string;
 837
 838     mo = string_output_visitor_new();
 839     object_property_get(obj, string_output_get_visitor(mo), name, errp);
 840     string = string_output_get_string(mo);
 841     string_output_visitor_cleanup(mo);
 842     return string;
 843 }
 844
 845 const char *object_property_get_type(Object *obj, const char *name, Error **errp)
 846 {
 847     ObjectProperty *prop = object_property_find(obj, name, errp);
 848     if (prop == NULL) {
 849         return NULL;
 850     }
 851
 852     return prop->type;
 853 }
 854
 855 Object *object_get_root(void)
 856 {
 857     static Object *root;
 858
 859     if (!root) {
 860         root = object_new("container");
 861     }
 862
 863     return root;
 864 }
 865
 866 static void object_get_child_property(Object *obj, Visitor *v, void *opaque,
 867                                       const char *name, Error **errp)
 868 {
 869     Object *child = opaque;
 870     gchar *path;
 871
 872     path = object_get_canonical_path(child);
 873     visit_type_str(v, &path, name, errp);
 874     g_free(path);
 875 }
 876
 877 static void object_finalize_child_property(Object *obj, const char *name,
 878                                            void *opaque)
 879 {
 880     Object *child = opaque;
 881
 882     object_unref(child);
 883 }
 884
 885 void object_property_add_child(Object *obj, const char *name,
 886                                Object *child, Error **errp)
 887 {
 888     gchar *type;
 889
 890     type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child)));
 891
 892     object_property_add(obj, name, type, object_get_child_property,
 893                         NULL, object_finalize_child_property, child, errp);
 894
 895     object_ref(child);
 896     g_assert(child->parent == NULL);
 897     child->parent = obj;
 898
 899     g_free(type);
 900 }
 901
 902 static void object_get_link_property(Object *obj, Visitor *v, void *opaque,
 903                                      const char *name, Error **errp)
 904 {
 905     Object **child = opaque;
 906     gchar *path;
 907
 908     if (*child) {
 909         path = object_get_canonical_path(*child);
 910         visit_type_str(v, &path, name, errp);
 911         g_free(path);
 912     } else {
 913         path = (gchar *)"";
 914         visit_type_str(v, &path, name, errp);
 915     }
 916 }
 917
 918 static void object_set_link_property(Object *obj, Visitor *v, void *opaque,
 919                                      const char *name, Error **errp)
 920 {
 921     Object **child = opaque;
 922     Object *old_target;
 923     bool ambiguous = false;
 924     const char *type;
 925     char *path;
 926     gchar *target_type;
 927
 928     type = object_property_get_type(obj, name, NULL);
 929
 930     visit_type_str(v, &path, name, errp);
 931
 932     old_target = *child;
 933     *child = NULL;
 934
 935     if (strcmp(path, "") != 0) {
 936         Object *target;
 937
 938         /* Go from link<FOO> to FOO.  */
 939         target_type = g_strndup(&type[5], strlen(type) - 6);
 940         target = object_resolve_path_type(path, target_type, &ambiguous);
 941
 942         if (ambiguous) {
 943             error_set(errp, QERR_AMBIGUOUS_PATH, path);
 944         } else if (target) {
 945             object_ref(target);
 946             *child = target;
 947         } else {
 948             target = object_resolve_path(path, &ambiguous);
 949             if (target || ambiguous) {
 950                 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type);
 951             } else {
 952                 error_set(errp, QERR_DEVICE_NOT_FOUND, path);
 953             }
 954         }
 955         g_free(target_type);
 956     }
 957
 958     g_free(path);
 959
 960     if (old_target != NULL) {
 961         object_unref(old_target);
 962     }
 963 }
 964
 965 void object_property_add_link(Object *obj, const char *name,
 966                               const char *type, Object **child,
 967                               Error **errp)
 968 {
 969     gchar *full_type;
 970
 971     full_type = g_strdup_printf("link<%s>", type);
 972
 973     object_property_add(obj, name, full_type,
 974                         object_get_link_property,
 975                         object_set_link_property,
 976                         NULL, child, errp);
 977
 978     g_free(full_type);
 979 }
 980
 981 gchar *object_get_canonical_path(Object *obj)
 982 {
 983     Object *root = object_get_root();
 984     char *newpath = NULL, *path = NULL;
 985
 986     while (obj != root) {
 987         ObjectProperty *prop = NULL;
 988
 989         g_assert(obj->parent != NULL);
 990
 991         QTAILQ_FOREACH(prop, &obj->parent->properties, node) {
 992             if (!object_property_is_child(prop)) {
 993                 continue;
 994             }
 995
 996             if (prop->opaque == obj) {
 997                 if (path) {
 998                     newpath = g_strdup_printf("%s/%s", prop->name, path);
 999                     g_free(path);
1000                     path = newpath;
1001                 } else {
1002                     path = g_strdup(prop->name);
1003                 }
1004                 break;
1005             }
1006         }
1007
1008         g_assert(prop != NULL);
1009
1010         obj = obj->parent;
1011     }
1012
1013     newpath = g_strdup_printf("/%s", path);
1014     g_free(path);
1015
1016     return newpath;
1017 }
1018
1019 Object *object_resolve_path_component(Object *parent, gchar *part)
1020 {
1021     ObjectProperty *prop = object_property_find(parent, part, NULL);
1022     if (prop == NULL) {
1023         return NULL;
1024     }
1025
1026     if (object_property_is_link(prop)) {
1027         return *(Object **)prop->opaque;
1028     } else if (object_property_is_child(prop)) {
1029         return prop->opaque;
1030     } else {
1031         return NULL;
1032     }
1033 }
1034
1035 static Object *object_resolve_abs_path(Object *parent,
1036                                           gchar **parts,
1037                                           const char *typename,
1038                                           int index)
1039 {
1040     Object *child;
1041
1042     if (parts[index] == NULL) {
1043         return object_dynamic_cast(parent, typename);
1044     }
1045
1046     if (strcmp(parts[index], "") == 0) {
1047         return object_resolve_abs_path(parent, parts, typename, index + 1);
1048     }
1049
1050     child = object_resolve_path_component(parent, parts[index]);
1051     if (!child) {
1052         return NULL;
1053     }
1054
1055     return object_resolve_abs_path(child, parts, typename, index + 1);
1056 }
1057
1058 static Object *object_resolve_partial_path(Object *parent,
1059                                               gchar **parts,
1060                                               const char *typename,
1061                                               bool *ambiguous)
1062 {
1063     Object *obj;
1064     ObjectProperty *prop;
1065
1066     obj = object_resolve_abs_path(parent, parts, typename, 0);
1067
1068     QTAILQ_FOREACH(prop, &parent->properties, node) {
1069         Object *found;
1070
1071         if (!object_property_is_child(prop)) {
1072             continue;
1073         }
1074
1075         found = object_resolve_partial_path(prop->opaque, parts,
1076                                             typename, ambiguous);
1077         if (found) {
1078             if (obj) {
1079                 if (ambiguous) {
1080                     *ambiguous = true;
1081                 }
1082                 return NULL;
1083             }
1084             obj = found;
1085         }
1086
1087         if (ambiguous && *ambiguous) {
1088             return NULL;
1089         }
1090     }
1091
1092     return obj;
1093 }
1094
1095 Object *object_resolve_path_type(const char *path, const char *typename,
1096                                  bool *ambiguous)
1097 {
1098     bool partial_path = true;
1099     Object *obj;
1100     gchar **parts;
1101
1102     parts = g_strsplit(path, "/", 0);
1103     if (parts == NULL || parts[0] == NULL) {
1104         g_strfreev(parts);
1105         return object_get_root();
1106     }
1107
1108     if (strcmp(parts[0], "") == 0) {
1109         partial_path = false;
1110     }
1111
1112     if (partial_path) {
1113         if (ambiguous) {
1114             *ambiguous = false;
1115         }
1116         obj = object_resolve_partial_path(object_get_root(), parts,
1117                                           typename, ambiguous);
1118     } else {
1119         obj = object_resolve_abs_path(object_get_root(), parts, typename, 1);
1120     }
1121
1122     g_strfreev(parts);
1123
1124     return obj;
1125 }
1126
1127 Object *object_resolve_path(const char *path, bool *ambiguous)
1128 {
1129     return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
1130 }
1131
1132 typedef struct StringProperty
1133 {
1134     char *(*get)(Object *, Error **);
1135     void (*set)(Object *, const char *, Error **);
1136 } StringProperty;
1137
1138 static void property_get_str(Object *obj, Visitor *v, void *opaque,
1139                              const char *name, Error **errp)
1140 {
1141     StringProperty *prop = opaque;
1142     char *value;
1143
1144     value = prop->get(obj, errp);
1145     if (value) {
1146         visit_type_str(v, &value, name, errp);
1147         g_free(value);
1148     }
1149 }
1150
1151 static void property_set_str(Object *obj, Visitor *v, void *opaque,
1152                              const char *name, Error **errp)
1153 {
1154     StringProperty *prop = opaque;
1155     char *value;
1156     Error *local_err = NULL;
1157
1158     visit_type_str(v, &value, name, &local_err);
1159     if (local_err) {
1160         error_propagate(errp, local_err);
1161         return;
1162     }
1163
1164     prop->set(obj, value, errp);
1165     g_free(value);
1166 }
1167
1168 static void property_release_str(Object *obj, const char *name,
1169                                  void *opaque)
1170 {
1171     StringProperty *prop = opaque;
1172     g_free(prop);
1173 }
1174
1175 void object_property_add_str(Object *obj, const char *name,
1176                            char *(*get)(Object *, Error **),
1177                            void (*set)(Object *, const char *, Error **),
1178                            Error **errp)
1179 {
1180     StringProperty *prop = g_malloc0(sizeof(*prop));
1181
1182     prop->get = get;
1183     prop->set = set;
1184
1185     object_property_add(obj, name, "string",
1186                         get ? property_get_str : NULL,
1187                         set ? property_set_str : NULL,
1188                         property_release_str,
1189                         prop, errp);
1190 }
1191
1192 typedef struct BoolProperty
1193 {
1194     bool (*get)(Object *, Error **);
1195     void (*set)(Object *, bool, Error **);
1196 } BoolProperty;
1197
1198 static void property_get_bool(Object *obj, Visitor *v, void *opaque,
1199                               const char *name, Error **errp)
1200 {
1201     BoolProperty *prop = opaque;
1202     bool value;
1203
1204     value = prop->get(obj, errp);
1205     visit_type_bool(v, &value, name, errp);
1206 }
1207
1208 static void property_set_bool(Object *obj, Visitor *v, void *opaque,
1209                               const char *name, Error **errp)
1210 {
1211     BoolProperty *prop = opaque;
1212     bool value;
1213     Error *local_err = NULL;
1214
1215     visit_type_bool(v, &value, name, &local_err);
1216     if (local_err) {
1217         error_propagate(errp, local_err);
1218         return;
1219     }
1220
1221     prop->set(obj, value, errp);
1222 }
1223
1224 static void property_release_bool(Object *obj, const char *name,
1225                                   void *opaque)
1226 {
1227     BoolProperty *prop = opaque;
1228     g_free(prop);
1229 }
1230
1231 void object_property_add_bool(Object *obj, const char *name,
1232                               bool (*get)(Object *, Error **),
1233                               void (*set)(Object *, bool, Error **),
1234                               Error **errp)
1235 {
1236     BoolProperty *prop = g_malloc0(sizeof(*prop));
1237
1238     prop->get = get;
1239     prop->set = set;
1240
1241     object_property_add(obj, name, "bool",
1242                         get ? property_get_bool : NULL,
1243                         set ? property_set_bool : NULL,
1244                         property_release_bool,
1245                         prop, errp);
1246 }
1247
1248 static char *qdev_get_type(Object *obj, Error **errp)
1249 {
1250     return g_strdup(object_get_typename(obj));
1251 }
1252
1253 static void object_instance_init(Object *obj)
1254 {
1255     object_property_add_str(obj, "type", qdev_get_type, NULL, NULL);
1256 }
1257
1258 static void register_types(void)
1259 {
1260     static TypeInfo interface_info = {
1261         .name = TYPE_INTERFACE,
1262         .class_size = sizeof(InterfaceClass),
1263         .abstract = true,
1264     };
1265
1266     static TypeInfo object_info = {
1267         .name = TYPE_OBJECT,
1268         .instance_size = sizeof(Object),
1269         .instance_init = object_instance_init,
1270         .abstract = true,
1271     };
1272
1273     type_interface = type_register_internal(&interface_info);
1274     type_register_internal(&object_info);
1275 }
1276
1277 type_init(register_types)