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/osdep.h"
  14 #include "hw/qdev-core.h"
  15 #include "qapi/error.h"
  16 #include "qom/object.h"
  17 #include "qom/object_interfaces.h"
  18 #include "qemu/cutils.h"
  19 #include "qapi/visitor.h"
  20 #include "qapi/string-input-visitor.h"
  21 #include "qapi/string-output-visitor.h"
  22 #include "qapi/qobject-input-visitor.h"
  23 #include "qapi/qapi-builtin-visit.h"
  24 #include "qapi/qmp/qerror.h"
  25 #include "qapi/qmp/qjson.h"
  26 #include "trace.h"
  27
  28 /* TODO: replace QObject with a simpler visitor to avoid a dependency
  29  * of the QOM core on QObject?  */
  30 #include "qom/qom-qobject.h"
  31 #include "qapi/qmp/qbool.h"
  32 #include "qapi/qmp/qnum.h"
  33 #include "qapi/qmp/qstring.h"
  34 #include "qemu/error-report.h"
  35
  36 #define MAX_INTERFACES 32
  37
  38 typedef struct InterfaceImpl InterfaceImpl;
  39 typedef struct TypeImpl TypeImpl;
  40
  41 struct InterfaceImpl
  42 {
  43     const char *typename;
  44 };
  45
  46 struct TypeImpl
  47 {
  48     const char *name;
  49
  50     size_t class_size;
  51
  52     size_t instance_size;
  53
  54     void (*class_init)(ObjectClass *klass, void *data);
  55     void (*class_base_init)(ObjectClass *klass, void *data);
  56
  57     void *class_data;
  58
  59     void (*instance_init)(Object *obj);
  60     void (*instance_post_init)(Object *obj);
  61     void (*instance_finalize)(Object *obj);
  62
  63     bool abstract;
  64
  65     const char *parent;
  66     TypeImpl *parent_type;
  67
  68     ObjectClass *class;
  69
  70     int num_interfaces;
  71     InterfaceImpl interfaces[MAX_INTERFACES];
  72 };
  73
  74 static Type type_interface;
  75
  76 static GHashTable *type_table_get(void)
  77 {
  78     static GHashTable *type_table;
  79
  80     if (type_table == NULL) {
  81         type_table = g_hash_table_new(g_str_hash, g_str_equal);
  82     }
  83
  84     return type_table;
  85 }
  86
  87 static bool enumerating_types;
  88
  89 static void type_table_add(TypeImpl *ti)
  90 {
  91     assert(!enumerating_types);
  92     g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
  93 }
  94
  95 static TypeImpl *type_table_lookup(const char *name)
  96 {
  97     return g_hash_table_lookup(type_table_get(), name);
  98 }
  99
 100 static TypeImpl *type_new(const TypeInfo *info)
 101 {
 102     TypeImpl *ti = g_malloc0(sizeof(*ti));
 103     int i;
 104
 105     g_assert(info->name != NULL);
 106
 107     if (type_table_lookup(info->name) != NULL) {
 108         fprintf(stderr, "Registering `%s' which already exists\n", info->name);
 109         abort();
 110     }
 111
 112     ti->name = g_strdup(info->name);
 113     ti->parent = g_strdup(info->parent);
 114
 115     ti->class_size = info->class_size;
 116     ti->instance_size = info->instance_size;
 117
 118     ti->class_init = info->class_init;
 119     ti->class_base_init = info->class_base_init;
 120     ti->class_data = info->class_data;
 121
 122     ti->instance_init = info->instance_init;
 123     ti->instance_post_init = info->instance_post_init;
 124     ti->instance_finalize = info->instance_finalize;
 125
 126     ti->abstract = info->abstract;
 127
 128     for (i = 0; info->interfaces && info->interfaces[i].type; i++) {
 129         ti->interfaces[i].typename = g_strdup(info->interfaces[i].type);
 130     }
 131     ti->num_interfaces = i;
 132
 133     return ti;
 134 }
 135
 136 static TypeImpl *type_register_internal(const TypeInfo *info)
 137 {
 138     TypeImpl *ti;
 139     ti = type_new(info);
 140
 141     type_table_add(ti);
 142     return ti;
 143 }
 144
 145 TypeImpl *type_register(const TypeInfo *info)
 146 {
 147     assert(info->parent);
 148     return type_register_internal(info);
 149 }
 150
 151 TypeImpl *type_register_static(const TypeInfo *info)
 152 {
 153     return type_register(info);
 154 }
 155
 156 void type_register_static_array(const TypeInfo *infos, int nr_infos)
 157 {
 158     int i;
 159
 160     for (i = 0; i < nr_infos; i++) {
 161         type_register_static(&infos[i]);
 162     }
 163 }
 164
 165 static TypeImpl *type_get_by_name(const char *name)
 166 {
 167     if (name == NULL) {
 168         return NULL;
 169     }
 170
 171     return type_table_lookup(name);
 172 }
 173
 174 static TypeImpl *type_get_parent(TypeImpl *type)
 175 {
 176     if (!type->parent_type && type->parent) {
 177         type->parent_type = type_get_by_name(type->parent);
 178         if (!type->parent_type) {
 179             fprintf(stderr, "Type '%s' is missing its parent '%s'\n",
 180                     type->name, type->parent);
 181             abort();
 182         }
 183     }
 184
 185     return type->parent_type;
 186 }
 187
 188 static bool type_has_parent(TypeImpl *type)
 189 {
 190     return (type->parent != NULL);
 191 }
 192
 193 static size_t type_class_get_size(TypeImpl *ti)
 194 {
 195     if (ti->class_size) {
 196         return ti->class_size;
 197     }
 198
 199     if (type_has_parent(ti)) {
 200         return type_class_get_size(type_get_parent(ti));
 201     }
 202
 203     return sizeof(ObjectClass);
 204 }
 205
 206 static size_t type_object_get_size(TypeImpl *ti)
 207 {
 208     if (ti->instance_size) {
 209         return ti->instance_size;
 210     }
 211
 212     if (type_has_parent(ti)) {
 213         return type_object_get_size(type_get_parent(ti));
 214     }
 215
 216     return 0;
 217 }
 218
 219 size_t object_type_get_instance_size(const char *typename)
 220 {
 221     TypeImpl *type = type_get_by_name(typename);
 222
 223     g_assert(type != NULL);
 224     return type_object_get_size(type);
 225 }
 226
 227 static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type)
 228 {
 229     assert(target_type);
 230
 231     /* Check if target_type is a direct ancestor of type */
 232     while (type) {
 233         if (type == target_type) {
 234             return true;
 235         }
 236
 237         type = type_get_parent(type);
 238     }
 239
 240     return false;
 241 }
 242
 243 static void type_initialize(TypeImpl *ti);
 244
 245 static void type_initialize_interface(TypeImpl *ti, TypeImpl *interface_type,
 246                                       TypeImpl *parent_type)
 247 {
 248     InterfaceClass *new_iface;
 249     TypeInfo info = { };
 250     TypeImpl *iface_impl;
 251
 252     info.parent = parent_type->name;
 253     info.name = g_strdup_printf("%s::%s", ti->name, interface_type->name);
 254     info.abstract = true;
 255
 256     iface_impl = type_new(&info);
 257     iface_impl->parent_type = parent_type;
 258     type_initialize(iface_impl);
 259     g_free((char *)info.name);
 260
 261     new_iface = (InterfaceClass *)iface_impl->class;
 262     new_iface->concrete_class = ti->class;
 263     new_iface->interface_type = interface_type;
 264
 265     ti->class->interfaces = g_slist_append(ti->class->interfaces, new_iface);
 266 }
 267
 268 static void object_property_free(gpointer data)
 269 {
 270     ObjectProperty *prop = data;
 271
 272     if (prop->defval) {
 273         qobject_unref(prop->defval);
 274         prop->defval = NULL;
 275     }
 276     g_free(prop->name);
 277     g_free(prop->type);
 278     g_free(prop->description);
 279     g_free(prop);
 280 }
 281
 282 static void type_initialize(TypeImpl *ti)
 283 {
 284     TypeImpl *parent;
 285
 286     if (ti->class) {
 287         return;
 288     }
 289
 290     ti->class_size = type_class_get_size(ti);
 291     ti->instance_size = type_object_get_size(ti);
 292     /* Any type with zero instance_size is implicitly abstract.
 293      * This means interface types are all abstract.
 294      */
 295     if (ti->instance_size == 0) {
 296         ti->abstract = true;
 297     }
 298     if (type_is_ancestor(ti, type_interface)) {
 299         assert(ti->instance_size == 0);
 300         assert(ti->abstract);
 301         assert(!ti->instance_init);
 302         assert(!ti->instance_post_init);
 303         assert(!ti->instance_finalize);
 304         assert(!ti->num_interfaces);
 305     }
 306     ti->class = g_malloc0(ti->class_size);
 307
 308     parent = type_get_parent(ti);
 309     if (parent) {
 310         type_initialize(parent);
 311         GSList *e;
 312         int i;
 313
 314         g_assert(parent->class_size <= ti->class_size);
 315         g_assert(parent->instance_size <= ti->instance_size);
 316         memcpy(ti->class, parent->class, parent->class_size);
 317         ti->class->interfaces = NULL;
 318
 319         for (e = parent->class->interfaces; e; e = e->next) {
 320             InterfaceClass *iface = e->data;
 321             ObjectClass *klass = OBJECT_CLASS(iface);
 322
 323             type_initialize_interface(ti, iface->interface_type, klass->type);
 324         }
 325
 326         for (i = 0; i < ti->num_interfaces; i++) {
 327             TypeImpl *t = type_get_by_name(ti->interfaces[i].typename);
 328             if (!t) {
 329                 error_report("missing interface '%s' for object '%s'",
 330                              ti->interfaces[i].typename, parent->name);
 331                 abort();
 332             }
 333             for (e = ti->class->interfaces; e; e = e->next) {
 334                 TypeImpl *target_type = OBJECT_CLASS(e->data)->type;
 335
 336                 if (type_is_ancestor(target_type, t)) {
 337                     break;
 338                 }
 339             }
 340
 341             if (e) {
 342                 continue;
 343             }
 344
 345             type_initialize_interface(ti, t, t);
 346         }
 347     }
 348
 349     ti->class->properties = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 350                                                   object_property_free);
 351
 352     ti->class->type = ti;
 353
 354     while (parent) {
 355         if (parent->class_base_init) {
 356             parent->class_base_init(ti->class, ti->class_data);
 357         }
 358         parent = type_get_parent(parent);
 359     }
 360
 361     if (ti->class_init) {
 362         ti->class_init(ti->class, ti->class_data);
 363     }
 364 }
 365
 366 static void object_init_with_type(Object *obj, TypeImpl *ti)
 367 {
 368     if (type_has_parent(ti)) {
 369         object_init_with_type(obj, type_get_parent(ti));
 370     }
 371
 372     if (ti->instance_init) {
 373         ti->instance_init(obj);
 374     }
 375 }
 376
 377 static void object_post_init_with_type(Object *obj, TypeImpl *ti)
 378 {
 379     if (ti->instance_post_init) {
 380         ti->instance_post_init(obj);
 381     }
 382
 383     if (type_has_parent(ti)) {
 384         object_post_init_with_type(obj, type_get_parent(ti));
 385     }
 386 }
 387
 388 bool object_apply_global_props(Object *obj, const GPtrArray *props,
 389                                Error **errp)
 390 {
 391     int i;
 392
 393     if (!props) {
 394         return true;
 395     }
 396
 397     for (i = 0; i < props->len; i++) {
 398         GlobalProperty *p = g_ptr_array_index(props, i);
 399         Error *err = NULL;
 400
 401         if (object_dynamic_cast(obj, p->driver) == NULL) {
 402             continue;
 403         }
 404         if (p->optional && !object_property_find(obj, p->property, NULL)) {
 405             continue;
 406         }
 407         p->used = true;
 408         if (!object_property_parse(obj, p->property, p->value, &err)) {
 409             error_prepend(&err, "can't apply global %s.%s=%s: ",
 410                           p->driver, p->property, p->value);
 411             /*
 412              * If errp != NULL, propagate error and return.
 413              * If errp == NULL, report a warning, but keep going
 414              * with the remaining globals.
 415              */
 416             if (errp) {
 417                 error_propagate(errp, err);
 418                 return false;
 419             } else {
 420                 warn_report_err(err);
 421             }
 422         }
 423     }
 424
 425     return true;
 426 }
 427
 428 /*
 429  * Global property defaults
 430  * Slot 0: accelerator's global property defaults
 431  * Slot 1: machine's global property defaults
 432  * Slot 2: global properties from legacy command line option
 433  * Each is a GPtrArray of of GlobalProperty.
 434  * Applied in order, later entries override earlier ones.
 435  */
 436 static GPtrArray *object_compat_props[3];
 437
 438 /*
 439  * Retrieve @GPtrArray for global property defined with options
 440  * other than "-global".  These are generally used for syntactic
 441  * sugar and legacy command line options.
 442  */
 443 void object_register_sugar_prop(const char *driver, const char *prop, const char *value)
 444 {
 445     GlobalProperty *g;
 446     if (!object_compat_props[2]) {
 447         object_compat_props[2] = g_ptr_array_new();
 448     }
 449     g = g_new0(GlobalProperty, 1);
 450     g->driver = g_strdup(driver);
 451     g->property = g_strdup(prop);
 452     g->value = g_strdup(value);
 453     g_ptr_array_add(object_compat_props[2], g);
 454 }
 455
 456 /*
 457  * Set machine's global property defaults to @compat_props.
 458  * May be called at most once.
 459  */
 460 void object_set_machine_compat_props(GPtrArray *compat_props)
 461 {
 462     assert(!object_compat_props[1]);
 463     object_compat_props[1] = compat_props;
 464 }
 465
 466 /*
 467  * Set accelerator's global property defaults to @compat_props.
 468  * May be called at most once.
 469  */
 470 void object_set_accelerator_compat_props(GPtrArray *compat_props)
 471 {
 472     assert(!object_compat_props[0]);
 473     object_compat_props[0] = compat_props;
 474 }
 475
 476 void object_apply_compat_props(Object *obj)
 477 {
 478     int i;
 479
 480     for (i = 0; i < ARRAY_SIZE(object_compat_props); i++) {
 481         object_apply_global_props(obj, object_compat_props[i],
 482                                   i == 2 ? &error_fatal : &error_abort);
 483     }
 484 }
 485
 486 static void object_class_property_init_all(Object *obj)
 487 {
 488     ObjectPropertyIterator iter;
 489     ObjectProperty *prop;
 490
 491     object_class_property_iter_init(&iter, object_get_class(obj));
 492     while ((prop = object_property_iter_next(&iter))) {
 493         if (prop->init) {
 494             prop->init(obj, prop);
 495         }
 496     }
 497 }
 498
 499 static void object_initialize_with_type(Object *obj, size_t size, TypeImpl *type)
 500 {
 501     type_initialize(type);
 502
 503     g_assert(type->instance_size >= sizeof(Object));
 504     g_assert(type->abstract == false);
 505     g_assert(size >= type->instance_size);
 506
 507     memset(obj, 0, type->instance_size);
 508     obj->class = type->class;
 509     object_ref(obj);
 510     object_class_property_init_all(obj);
 511     obj->properties = g_hash_table_new_full(g_str_hash, g_str_equal,
 512                                             NULL, object_property_free);
 513     object_init_with_type(obj, type);
 514     object_post_init_with_type(obj, type);
 515 }
 516
 517 void object_initialize(void *data, size_t size, const char *typename)
 518 {
 519     TypeImpl *type = type_get_by_name(typename);
 520
 521 #ifdef CONFIG_MODULES
 522     if (!type) {
 523         module_load_qom_one(typename);
 524         type = type_get_by_name(typename);
 525     }
 526 #endif
 527     if (!type) {
 528         error_report("missing object type '%s'", typename);
 529         abort();
 530     }
 531
 532     object_initialize_with_type(data, size, type);
 533 }
 534
 535 bool object_initialize_child_with_props(Object *parentobj,
 536                                         const char *propname,
 537                                         void *childobj, size_t size,
 538                                         const char *type,
 539                                         Error **errp, ...)
 540 {
 541     va_list vargs;
 542     bool ok;
 543
 544     va_start(vargs, errp);
 545     ok = object_initialize_child_with_propsv(parentobj, propname,
 546                                              childobj, size, type, errp,
 547                                              vargs);
 548     va_end(vargs);
 549     return ok;
 550 }
 551
 552 bool object_initialize_child_with_propsv(Object *parentobj,
 553                                          const char *propname,
 554                                          void *childobj, size_t size,
 555                                          const char *type,
 556                                          Error **errp, va_list vargs)
 557 {
 558     bool ok = false;
 559     Object *obj;
 560     UserCreatable *uc;
 561
 562     object_initialize(childobj, size, type);
 563     obj = OBJECT(childobj);
 564
 565     if (!object_set_propv(obj, errp, vargs)) {
 566         goto out;
 567     }
 568
 569     object_property_add_child(parentobj, propname, obj);
 570
 571     uc = (UserCreatable *)object_dynamic_cast(obj, TYPE_USER_CREATABLE);
 572     if (uc) {
 573         if (!user_creatable_complete(uc, errp)) {
 574             object_unparent(obj);
 575             goto out;
 576         }
 577     }
 578
 579     ok = true;
 580
 581 out:
 582     /*
 583      * We want @obj's reference to be 1 on success, 0 on failure.
 584      * On success, it's 2: one taken by object_initialize(), and one
 585      * by object_property_add_child().
 586      * On failure in object_initialize() or earlier, it's 1.
 587      * On failure afterwards, it's also 1: object_unparent() releases
 588      * the reference taken by object_property_add_child().
 589      */
 590     object_unref(obj);
 591     return ok;
 592 }
 593
 594 void object_initialize_child_internal(Object *parent,
 595                                       const char *propname,
 596                                       void *child, size_t size,
 597                                       const char *type)
 598 {
 599     object_initialize_child_with_props(parent, propname, child, size, type,
 600                                        &error_abort, NULL);
 601 }
 602
 603 static inline bool object_property_is_child(ObjectProperty *prop)
 604 {
 605     return strstart(prop->type, "child<", NULL);
 606 }
 607
 608 static void object_property_del_all(Object *obj)
 609 {
 610     g_autoptr(GHashTable) done = g_hash_table_new(NULL, NULL);
 611     ObjectProperty *prop;
 612     ObjectPropertyIterator iter;
 613     bool released;
 614
 615     do {
 616         released = false;
 617         object_property_iter_init(&iter, obj);
 618         while ((prop = object_property_iter_next(&iter)) != NULL) {
 619             if (g_hash_table_add(done, prop)) {
 620                 if (prop->release) {
 621                     prop->release(obj, prop->name, prop->opaque);
 622                     released = true;
 623                     break;
 624                 }
 625             }
 626         }
 627     } while (released);
 628
 629     g_hash_table_unref(obj->properties);
 630 }
 631
 632 static void object_property_del_child(Object *obj, Object *child)
 633 {
 634     ObjectProperty *prop;
 635     GHashTableIter iter;
 636     gpointer key, value;
 637
 638     g_hash_table_iter_init(&iter, obj->properties);
 639     while (g_hash_table_iter_next(&iter, &key, &value)) {
 640         prop = value;
 641         if (object_property_is_child(prop) && prop->opaque == child) {
 642             if (prop->release) {
 643                 prop->release(obj, prop->name, prop->opaque);
 644                 prop->release = NULL;
 645             }
 646             break;
 647         }
 648     }
 649     g_hash_table_iter_init(&iter, obj->properties);
 650     while (g_hash_table_iter_next(&iter, &key, &value)) {
 651         prop = value;
 652         if (object_property_is_child(prop) && prop->opaque == child) {
 653             g_hash_table_iter_remove(&iter);
 654             break;
 655         }
 656     }
 657 }
 658
 659 void object_unparent(Object *obj)
 660 {
 661     if (obj->parent) {
 662         object_property_del_child(obj->parent, obj);
 663     }
 664 }
 665
 666 static void object_deinit(Object *obj, TypeImpl *type)
 667 {
 668     if (type->instance_finalize) {
 669         type->instance_finalize(obj);
 670     }
 671
 672     if (type_has_parent(type)) {
 673         object_deinit(obj, type_get_parent(type));
 674     }
 675 }
 676
 677 static void object_finalize(void *data)
 678 {
 679     Object *obj = data;
 680     TypeImpl *ti = obj->class->type;
 681
 682     object_property_del_all(obj);
 683     object_deinit(obj, ti);
 684
 685     g_assert(obj->ref == 0);
 686     if (obj->free) {
 687         obj->free(obj);
 688     }
 689 }
 690
 691 static Object *object_new_with_type(Type type)
 692 {
 693     Object *obj;
 694
 695     g_assert(type != NULL);
 696     type_initialize(type);
 697
 698     obj = g_malloc(type->instance_size);
 699     object_initialize_with_type(obj, type->instance_size, type);
 700     obj->free = g_free;
 701
 702     return obj;
 703 }
 704
 705 Object *object_new_with_class(ObjectClass *klass)
 706 {
 707     return object_new_with_type(klass->type);
 708 }
 709
 710 Object *object_new(const char *typename)
 711 {
 712     TypeImpl *ti = type_get_by_name(typename);
 713
 714     return object_new_with_type(ti);
 715 }
 716
 717
 718 Object *object_new_with_props(const char *typename,
 719                               Object *parent,
 720                               const char *id,
 721                               Error **errp,
 722                               ...)
 723 {
 724     va_list vargs;
 725     Object *obj;
 726
 727     va_start(vargs, errp);
 728     obj = object_new_with_propv(typename, parent, id, errp, vargs);
 729     va_end(vargs);
 730
 731     return obj;
 732 }
 733
 734
 735 Object *object_new_with_propv(const char *typename,
 736                               Object *parent,
 737                               const char *id,
 738                               Error **errp,
 739                               va_list vargs)
 740 {
 741     Object *obj;
 742     ObjectClass *klass;
 743     UserCreatable *uc;
 744
 745     klass = object_class_by_name(typename);
 746     if (!klass) {
 747         error_setg(errp, "invalid object type: %s", typename);
 748         return NULL;
 749     }
 750
 751     if (object_class_is_abstract(klass)) {
 752         error_setg(errp, "object type '%s' is abstract", typename);
 753         return NULL;
 754     }
 755     obj = object_new_with_type(klass->type);
 756
 757     if (!object_set_propv(obj, errp, vargs)) {
 758         goto error;
 759     }
 760
 761     if (id != NULL) {
 762         object_property_add_child(parent, id, obj);
 763     }
 764
 765     uc = (UserCreatable *)object_dynamic_cast(obj, TYPE_USER_CREATABLE);
 766     if (uc) {
 767         if (!user_creatable_complete(uc, errp)) {
 768             if (id != NULL) {
 769                 object_unparent(obj);
 770             }
 771             goto error;
 772         }
 773     }
 774
 775     object_unref(obj);
 776     return obj;
 777
 778  error:
 779     object_unref(obj);
 780     return NULL;
 781 }
 782
 783
 784 bool object_set_props(Object *obj,
 785                      Error **errp,
 786                      ...)
 787 {
 788     va_list vargs;
 789     bool ret;
 790
 791     va_start(vargs, errp);
 792     ret = object_set_propv(obj, errp, vargs);
 793     va_end(vargs);
 794
 795     return ret;
 796 }
 797
 798
 799 bool object_set_propv(Object *obj,
 800                      Error **errp,
 801                      va_list vargs)
 802 {
 803     const char *propname;
 804
 805     propname = va_arg(vargs, char *);
 806     while (propname != NULL) {
 807         const char *value = va_arg(vargs, char *);
 808
 809         g_assert(value != NULL);
 810         if (!object_property_parse(obj, propname, value, errp)) {
 811             return false;
 812         }
 813         propname = va_arg(vargs, char *);
 814     }
 815
 816     return true;
 817 }
 818
 819
 820 Object *object_dynamic_cast(Object *obj, const char *typename)
 821 {
 822     if (obj && object_class_dynamic_cast(object_get_class(obj), typename)) {
 823         return obj;
 824     }
 825
 826     return NULL;
 827 }
 828
 829 Object *object_dynamic_cast_assert(Object *obj, const char *typename,
 830                                    const char *file, int line, const char *func)
 831 {
 832     trace_object_dynamic_cast_assert(obj ? obj->class->type->name : "(null)",
 833                                      typename, file, line, func);
 834
 835 #ifdef CONFIG_QOM_CAST_DEBUG
 836     int i;
 837     Object *inst;
 838
 839     for (i = 0; obj && i < OBJECT_CLASS_CAST_CACHE; i++) {
 840         if (atomic_read(&obj->class->object_cast_cache[i]) == typename) {
 841             goto out;
 842         }
 843     }
 844
 845     inst = object_dynamic_cast(obj, typename);
 846
 847     if (!inst && obj) {
 848         fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
 849                 file, line, func, obj, typename);
 850         abort();
 851     }
 852
 853     assert(obj == inst);
 854
 855     if (obj && obj == inst) {
 856         for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
 857             atomic_set(&obj->class->object_cast_cache[i - 1],
 858                        atomic_read(&obj->class->object_cast_cache[i]));
 859         }
 860         atomic_set(&obj->class->object_cast_cache[i - 1], typename);
 861     }
 862
 863 out:
 864 #endif
 865     return obj;
 866 }
 867
 868 ObjectClass *object_class_dynamic_cast(ObjectClass *class,
 869                                        const char *typename)
 870 {
 871     ObjectClass *ret = NULL;
 872     TypeImpl *target_type;
 873     TypeImpl *type;
 874
 875     if (!class) {
 876         return NULL;
 877     }
 878
 879     /* A simple fast path that can trigger a lot for leaf classes.  */
 880     type = class->type;
 881     if (type->name == typename) {
 882         return class;
 883     }
 884
 885     target_type = type_get_by_name(typename);
 886     if (!target_type) {
 887         /* target class type unknown, so fail the cast */
 888         return NULL;
 889     }
 890
 891     if (type->class->interfaces &&
 892             type_is_ancestor(target_type, type_interface)) {
 893         int found = 0;
 894         GSList *i;
 895
 896         for (i = class->interfaces; i; i = i->next) {
 897             ObjectClass *target_class = i->data;
 898
 899             if (type_is_ancestor(target_class->type, target_type)) {
 900                 ret = target_class;
 901                 found++;
 902             }
 903          }
 904
 905         /* The match was ambiguous, don't allow a cast */
 906         if (found > 1) {
 907             ret = NULL;
 908         }
 909     } else if (type_is_ancestor(type, target_type)) {
 910         ret = class;
 911     }
 912
 913     return ret;
 914 }
 915
 916 ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class,
 917                                               const char *typename,
 918                                               const char *file, int line,
 919                                               const char *func)
 920 {
 921     ObjectClass *ret;
 922
 923     trace_object_class_dynamic_cast_assert(class ? class->type->name : "(null)",
 924                                            typename, file, line, func);
 925
 926 #ifdef CONFIG_QOM_CAST_DEBUG
 927     int i;
 928
 929     for (i = 0; class && i < OBJECT_CLASS_CAST_CACHE; i++) {
 930         if (atomic_read(&class->class_cast_cache[i]) == typename) {
 931             ret = class;
 932             goto out;
 933         }
 934     }
 935 #else
 936     if (!class || !class->interfaces) {
 937         return class;
 938     }
 939 #endif
 940
 941     ret = object_class_dynamic_cast(class, typename);
 942     if (!ret && class) {
 943         fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
 944                 file, line, func, class, typename);
 945         abort();
 946     }
 947
 948 #ifdef CONFIG_QOM_CAST_DEBUG
 949     if (class && ret == class) {
 950         for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
 951             atomic_set(&class->class_cast_cache[i - 1],
 952                        atomic_read(&class->class_cast_cache[i]));
 953         }
 954         atomic_set(&class->class_cast_cache[i - 1], typename);
 955     }
 956 out:
 957 #endif
 958     return ret;
 959 }
 960
 961 const char *object_get_typename(const Object *obj)
 962 {
 963     return obj->class->type->name;
 964 }
 965
 966 ObjectClass *object_get_class(Object *obj)
 967 {
 968     return obj->class;
 969 }
 970
 971 bool object_class_is_abstract(ObjectClass *klass)
 972 {
 973     return klass->type->abstract;
 974 }
 975
 976 const char *object_class_get_name(ObjectClass *klass)
 977 {
 978     return klass->type->name;
 979 }
 980
 981 ObjectClass *object_class_by_name(const char *typename)
 982 {
 983     TypeImpl *type = type_get_by_name(typename);
 984
 985     if (!type) {
 986         return NULL;
 987     }
 988
 989     type_initialize(type);
 990
 991     return type->class;
 992 }
 993
 994 ObjectClass *module_object_class_by_name(const char *typename)
 995 {
 996     ObjectClass *oc;
 997
 998     oc = object_class_by_name(typename);
 999 #ifdef CONFIG_MODULES
1000     if (!oc) {
1001         module_load_qom_one(typename);
1002         oc = object_class_by_name(typename);
1003     }
1004 #endif
1005     return oc;
1006 }
1007
1008 ObjectClass *object_class_get_parent(ObjectClass *class)
1009 {
1010     TypeImpl *type = type_get_parent(class->type);
1011
1012     if (!type) {
1013         return NULL;
1014     }
1015
1016     type_initialize(type);
1017
1018     return type->class;
1019 }
1020
1021 typedef struct OCFData
1022 {
1023     void (*fn)(ObjectClass *klass, void *opaque);
1024     const char *implements_type;
1025     bool include_abstract;
1026     void *opaque;
1027 } OCFData;
1028
1029 static void object_class_foreach_tramp(gpointer key, gpointer value,
1030                                        gpointer opaque)
1031 {
1032     OCFData *data = opaque;
1033     TypeImpl *type = value;
1034     ObjectClass *k;
1035
1036     type_initialize(type);
1037     k = type->class;
1038
1039     if (!data->include_abstract && type->abstract) {
1040         return;
1041     }
1042
1043     if (data->implements_type &&
1044         !object_class_dynamic_cast(k, data->implements_type)) {
1045         return;
1046     }
1047
1048     data->fn(k, data->opaque);
1049 }
1050
1051 void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
1052                           const char *implements_type, bool include_abstract,
1053                           void *opaque)
1054 {
1055     OCFData data = { fn, implements_type, include_abstract, opaque };
1056
1057     enumerating_types = true;
1058     g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data);
1059     enumerating_types = false;
1060 }
1061
1062 static int do_object_child_foreach(Object *obj,
1063                                    int (*fn)(Object *child, void *opaque),
1064                                    void *opaque, bool recurse)
1065 {
1066     GHashTableIter iter;
1067     ObjectProperty *prop;
1068     int ret = 0;
1069
1070     g_hash_table_iter_init(&iter, obj->properties);
1071     while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
1072         if (object_property_is_child(prop)) {
1073             Object *child = prop->opaque;
1074
1075             ret = fn(child, opaque);
1076             if (ret != 0) {
1077                 break;
1078             }
1079             if (recurse) {
1080                 ret = do_object_child_foreach(child, fn, opaque, true);
1081                 if (ret != 0) {
1082                     break;
1083                 }
1084             }
1085         }
1086     }
1087     return ret;
1088 }
1089
1090 int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
1091                          void *opaque)
1092 {
1093     return do_object_child_foreach(obj, fn, opaque, false);
1094 }
1095
1096 int object_child_foreach_recursive(Object *obj,
1097                                    int (*fn)(Object *child, void *opaque),
1098                                    void *opaque)
1099 {
1100     return do_object_child_foreach(obj, fn, opaque, true);
1101 }
1102
1103 static void object_class_get_list_tramp(ObjectClass *klass, void *opaque)
1104 {
1105     GSList **list = opaque;
1106
1107     *list = g_slist_prepend(*list, klass);
1108 }
1109
1110 GSList *object_class_get_list(const char *implements_type,
1111                               bool include_abstract)
1112 {
1113     GSList *list = NULL;
1114
1115     object_class_foreach(object_class_get_list_tramp,
1116                          implements_type, include_abstract, &list);
1117     return list;
1118 }
1119
1120 static gint object_class_cmp(gconstpointer a, gconstpointer b)
1121 {
1122     return strcasecmp(object_class_get_name((ObjectClass *)a),
1123                       object_class_get_name((ObjectClass *)b));
1124 }
1125
1126 GSList *object_class_get_list_sorted(const char *implements_type,
1127                                      bool include_abstract)
1128 {
1129     return g_slist_sort(object_class_get_list(implements_type, include_abstract),
1130                         object_class_cmp);
1131 }
1132
1133 Object *object_ref(void *objptr)
1134 {
1135     Object *obj = OBJECT(objptr);
1136     if (!obj) {
1137         return NULL;
1138     }
1139     atomic_inc(&obj->ref);
1140     return obj;
1141 }
1142
1143 void object_unref(void *objptr)
1144 {
1145     Object *obj = OBJECT(objptr);
1146     if (!obj) {
1147         return;
1148     }
1149     g_assert(obj->ref > 0);
1150
1151     /* parent always holds a reference to its children */
1152     if (atomic_fetch_dec(&obj->ref) == 1) {
1153         object_finalize(obj);
1154     }
1155 }
1156
1157 ObjectProperty *
1158 object_property_try_add(Object *obj, const char *name, const char *type,
1159                         ObjectPropertyAccessor *get,
1160                         ObjectPropertyAccessor *set,
1161                         ObjectPropertyRelease *release,
1162                         void *opaque, Error **errp)
1163 {
1164     ObjectProperty *prop;
1165     size_t name_len = strlen(name);
1166
1167     if (name_len >= 3 && !memcmp(name + name_len - 3, "[*]", 4)) {
1168         int i;
1169         ObjectProperty *ret;
1170         char *name_no_array = g_strdup(name);
1171
1172         name_no_array[name_len - 3] = '\0';
1173         for (i = 0; ; ++i) {
1174             char *full_name = g_strdup_printf("%s[%d]", name_no_array, i);
1175
1176             ret = object_property_try_add(obj, full_name, type, get, set,
1177                                           release, opaque, NULL);
1178             g_free(full_name);
1179             if (ret) {
1180                 break;
1181             }
1182         }
1183         g_free(name_no_array);
1184         return ret;
1185     }
1186
1187     if (object_property_find(obj, name, NULL) != NULL) {
1188         error_setg(errp, "attempt to add duplicate property '%s' to object (type '%s')",
1189                    name, object_get_typename(obj));
1190         return NULL;
1191     }
1192
1193     prop = g_malloc0(sizeof(*prop));
1194
1195     prop->name = g_strdup(name);
1196     prop->type = g_strdup(type);
1197
1198     prop->get = get;
1199     prop->set = set;
1200     prop->release = release;
1201     prop->opaque = opaque;
1202
1203     g_hash_table_insert(obj->properties, prop->name, prop);
1204     return prop;
1205 }
1206
1207 ObjectProperty *
1208 object_property_add(Object *obj, const char *name, const char *type,
1209                     ObjectPropertyAccessor *get,
1210                     ObjectPropertyAccessor *set,
1211                     ObjectPropertyRelease *release,
1212                     void *opaque)
1213 {
1214     return object_property_try_add(obj, name, type, get, set, release,
1215                                    opaque, &error_abort);
1216 }
1217
1218 ObjectProperty *
1219 object_class_property_add(ObjectClass *klass,
1220                           const char *name,
1221                           const char *type,
1222                           ObjectPropertyAccessor *get,
1223                           ObjectPropertyAccessor *set,
1224                           ObjectPropertyRelease *release,
1225                           void *opaque)
1226 {
1227     ObjectProperty *prop;
1228
1229     assert(!object_class_property_find(klass, name, NULL));
1230
1231     prop = g_malloc0(sizeof(*prop));
1232
1233     prop->name = g_strdup(name);
1234     prop->type = g_strdup(type);
1235
1236     prop->get = get;
1237     prop->set = set;
1238     prop->release = release;
1239     prop->opaque = opaque;
1240
1241     g_hash_table_insert(klass->properties, prop->name, prop);
1242
1243     return prop;
1244 }
1245
1246 ObjectProperty *object_property_find(Object *obj, const char *name,
1247                                      Error **errp)
1248 {
1249     ObjectProperty *prop;
1250     ObjectClass *klass = object_get_class(obj);
1251
1252     prop = object_class_property_find(klass, name, NULL);
1253     if (prop) {
1254         return prop;
1255     }
1256
1257     prop = g_hash_table_lookup(obj->properties, name);
1258     if (prop) {
1259         return prop;
1260     }
1261
1262     error_setg(errp, "Property '.%s' not found", name);
1263     return NULL;
1264 }
1265
1266 void object_property_iter_init(ObjectPropertyIterator *iter,
1267                                Object *obj)
1268 {
1269     g_hash_table_iter_init(&iter->iter, obj->properties);
1270     iter->nextclass = object_get_class(obj);
1271 }
1272
1273 ObjectProperty *object_property_iter_next(ObjectPropertyIterator *iter)
1274 {
1275     gpointer key, val;
1276     while (!g_hash_table_iter_next(&iter->iter, &key, &val)) {
1277         if (!iter->nextclass) {
1278             return NULL;
1279         }
1280         g_hash_table_iter_init(&iter->iter, iter->nextclass->properties);
1281         iter->nextclass = object_class_get_parent(iter->nextclass);
1282     }
1283     return val;
1284 }
1285
1286 void object_class_property_iter_init(ObjectPropertyIterator *iter,
1287                                      ObjectClass *klass)
1288 {
1289     g_hash_table_iter_init(&iter->iter, klass->properties);
1290     iter->nextclass = object_class_get_parent(klass);
1291 }
1292
1293 ObjectProperty *object_class_property_find(ObjectClass *klass, const char *name,
1294                                            Error **errp)
1295 {
1296     ObjectProperty *prop;
1297     ObjectClass *parent_klass;
1298
1299     parent_klass = object_class_get_parent(klass);
1300     if (parent_klass) {
1301         prop = object_class_property_find(parent_klass, name, NULL);
1302         if (prop) {
1303             return prop;
1304         }
1305     }
1306
1307     prop = g_hash_table_lookup(klass->properties, name);
1308     if (!prop) {
1309         error_setg(errp, "Property '.%s' not found", name);
1310     }
1311     return prop;
1312 }
1313
1314 void object_property_del(Object *obj, const char *name)
1315 {
1316     ObjectProperty *prop = g_hash_table_lookup(obj->properties, name);
1317
1318     if (prop->release) {
1319         prop->release(obj, name, prop->opaque);
1320     }
1321     g_hash_table_remove(obj->properties, name);
1322 }
1323
1324 bool object_property_get(Object *obj, const char *name, Visitor *v,
1325                          Error **errp)
1326 {
1327     Error *err = NULL;
1328     ObjectProperty *prop = object_property_find(obj, name, errp);
1329
1330     if (prop == NULL) {
1331         return false;
1332     }
1333
1334     if (!prop->get) {
1335         error_setg(errp, QERR_PERMISSION_DENIED);
1336         return false;
1337     }
1338     prop->get(obj, v, name, prop->opaque, &err);
1339     error_propagate(errp, err);
1340     return !err;
1341 }
1342
1343 bool object_property_set(Object *obj, const char *name, Visitor *v,
1344                          Error **errp)
1345 {
1346     Error *err = NULL;
1347     ObjectProperty *prop = object_property_find(obj, name, errp);
1348
1349     if (prop == NULL) {
1350         return false;
1351     }
1352
1353     if (!prop->set) {
1354         error_setg(errp, QERR_PERMISSION_DENIED);
1355         return false;
1356     }
1357     prop->set(obj, v, name, prop->opaque, &err);
1358     error_propagate(errp, err);
1359     return !err;
1360 }
1361
1362 bool object_property_set_str(Object *obj, const char *name,
1363                              const char *value, Error **errp)
1364 {
1365     QString *qstr = qstring_from_str(value);
1366     bool ok = object_property_set_qobject(obj, name, QOBJECT(qstr), errp);
1367
1368     qobject_unref(qstr);
1369     return ok;
1370 }
1371
1372 char *object_property_get_str(Object *obj, const char *name,
1373                               Error **errp)
1374 {
1375     QObject *ret = object_property_get_qobject(obj, name, errp);
1376     char *retval;
1377
1378     if (!ret) {
1379         return NULL;
1380     }
1381
1382     retval = g_strdup(qobject_get_try_str(ret));
1383     if (!retval) {
1384         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
1385     }
1386
1387     qobject_unref(ret);
1388     return retval;
1389 }
1390
1391 bool object_property_set_link(Object *obj, const char *name,
1392                               Object *value, Error **errp)
1393 {
1394     g_autofree char *path = NULL;
1395
1396     if (value) {
1397         path = object_get_canonical_path(value);
1398     }
1399     return object_property_set_str(obj, name, path ?: "", errp);
1400 }
1401
1402 Object *object_property_get_link(Object *obj, const char *name,
1403                                  Error **errp)
1404 {
1405     char *str = object_property_get_str(obj, name, errp);
1406     Object *target = NULL;
1407
1408     if (str && *str) {
1409         target = object_resolve_path(str, NULL);
1410         if (!target) {
1411             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1412                       "Device '%s' not found", str);
1413         }
1414     }
1415
1416     g_free(str);
1417     return target;
1418 }
1419
1420 bool object_property_set_bool(Object *obj, const char *name,
1421                               bool value, Error **errp)
1422 {
1423     QBool *qbool = qbool_from_bool(value);
1424     bool ok = object_property_set_qobject(obj, name, QOBJECT(qbool), errp);
1425
1426     qobject_unref(qbool);
1427     return ok;
1428 }
1429
1430 bool object_property_get_bool(Object *obj, const char *name,
1431                               Error **errp)
1432 {
1433     QObject *ret = object_property_get_qobject(obj, name, errp);
1434     QBool *qbool;
1435     bool retval;
1436
1437     if (!ret) {
1438         return false;
1439     }
1440     qbool = qobject_to(QBool, ret);
1441     if (!qbool) {
1442         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean");
1443         retval = false;
1444     } else {
1445         retval = qbool_get_bool(qbool);
1446     }
1447
1448     qobject_unref(ret);
1449     return retval;
1450 }
1451
1452 bool object_property_set_int(Object *obj, const char *name,
1453                              int64_t value, Error **errp)
1454 {
1455     QNum *qnum = qnum_from_int(value);
1456     bool ok = object_property_set_qobject(obj, name, QOBJECT(qnum), errp);
1457
1458     qobject_unref(qnum);
1459     return ok;
1460 }
1461
1462 int64_t object_property_get_int(Object *obj, const char *name,
1463                                 Error **errp)
1464 {
1465     QObject *ret = object_property_get_qobject(obj, name, errp);
1466     QNum *qnum;
1467     int64_t retval;
1468
1469     if (!ret) {
1470         return -1;
1471     }
1472
1473     qnum = qobject_to(QNum, ret);
1474     if (!qnum || !qnum_get_try_int(qnum, &retval)) {
1475         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "int");
1476         retval = -1;
1477     }
1478
1479     qobject_unref(ret);
1480     return retval;
1481 }
1482
1483 static void object_property_init_defval(Object *obj, ObjectProperty *prop)
1484 {
1485     Visitor *v = qobject_input_visitor_new(prop->defval);
1486
1487     assert(prop->set != NULL);
1488     prop->set(obj, v, prop->name, prop->opaque, &error_abort);
1489
1490     visit_free(v);
1491 }
1492
1493 static void object_property_set_default(ObjectProperty *prop, QObject *defval)
1494 {
1495     assert(!prop->defval);
1496     assert(!prop->init);
1497
1498     prop->defval = defval;
1499     prop->init = object_property_init_defval;
1500 }
1501
1502 void object_property_set_default_bool(ObjectProperty *prop, bool value)
1503 {
1504     object_property_set_default(prop, QOBJECT(qbool_from_bool(value)));
1505 }
1506
1507 void object_property_set_default_str(ObjectProperty *prop, const char *value)
1508 {
1509     object_property_set_default(prop, QOBJECT(qstring_from_str(value)));
1510 }
1511
1512 void object_property_set_default_int(ObjectProperty *prop, int64_t value)
1513 {
1514     object_property_set_default(prop, QOBJECT(qnum_from_int(value)));
1515 }
1516
1517 void object_property_set_default_uint(ObjectProperty *prop, uint64_t value)
1518 {
1519     object_property_set_default(prop, QOBJECT(qnum_from_uint(value)));
1520 }
1521
1522 bool object_property_set_uint(Object *obj, const char *name,
1523                               uint64_t value, Error **errp)
1524 {
1525     QNum *qnum = qnum_from_uint(value);
1526     bool ok = object_property_set_qobject(obj, name, QOBJECT(qnum), errp);
1527
1528     qobject_unref(qnum);
1529     return ok;
1530 }
1531
1532 uint64_t object_property_get_uint(Object *obj, const char *name,
1533                                   Error **errp)
1534 {
1535     QObject *ret = object_property_get_qobject(obj, name, errp);
1536     QNum *qnum;
1537     uint64_t retval;
1538
1539     if (!ret) {
1540         return 0;
1541     }
1542     qnum = qobject_to(QNum, ret);
1543     if (!qnum || !qnum_get_try_uint(qnum, &retval)) {
1544         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "uint");
1545         retval = 0;
1546     }
1547
1548     qobject_unref(ret);
1549     return retval;
1550 }
1551
1552 typedef struct EnumProperty {
1553     const QEnumLookup *lookup;
1554     int (*get)(Object *, Error **);
1555     void (*set)(Object *, int, Error **);
1556 } EnumProperty;
1557
1558 int object_property_get_enum(Object *obj, const char *name,
1559                              const char *typename, Error **errp)
1560 {
1561     char *str;
1562     int ret;
1563     ObjectProperty *prop = object_property_find(obj, name, errp);
1564     EnumProperty *enumprop;
1565
1566     if (prop == NULL) {
1567         return 0;
1568     }
1569
1570     if (!g_str_equal(prop->type, typename)) {
1571         error_setg(errp, "Property %s on %s is not '%s' enum type",
1572                    name, object_class_get_name(
1573                        object_get_class(obj)), typename);
1574         return 0;
1575     }
1576
1577     enumprop = prop->opaque;
1578
1579     str = object_property_get_str(obj, name, errp);
1580     if (!str) {
1581         return 0;
1582     }
1583
1584     ret = qapi_enum_parse(enumprop->lookup, str, -1, errp);
1585     g_free(str);
1586
1587     return ret;
1588 }
1589
1590 bool object_property_parse(Object *obj, const char *name,
1591                            const char *string, Error **errp)
1592 {
1593     Visitor *v = string_input_visitor_new(string);
1594     bool ok = object_property_set(obj, name, v, errp);
1595
1596     visit_free(v);
1597     return ok;
1598 }
1599
1600 char *object_property_print(Object *obj, const char *name, bool human,
1601                             Error **errp)
1602 {
1603     Visitor *v;
1604     char *string = NULL;
1605
1606     v = string_output_visitor_new(human, &string);
1607     if (!object_property_get(obj, name, v, errp)) {
1608         goto out;
1609     }
1610
1611     visit_complete(v, &string);
1612
1613 out:
1614     visit_free(v);
1615     return string;
1616 }
1617
1618 const char *object_property_get_type(Object *obj, const char *name, Error **errp)
1619 {
1620     ObjectProperty *prop = object_property_find(obj, name, errp);
1621     if (prop == NULL) {
1622         return NULL;
1623     }
1624
1625     return prop->type;
1626 }
1627
1628 Object *object_get_root(void)
1629 {
1630     static Object *root;
1631
1632     if (!root) {
1633         root = object_new("container");
1634     }
1635
1636     return root;
1637 }
1638
1639 Object *object_get_objects_root(void)
1640 {
1641     return container_get(object_get_root(), "/objects");
1642 }
1643
1644 Object *object_get_internal_root(void)
1645 {
1646     static Object *internal_root;
1647
1648     if (!internal_root) {
1649         internal_root = object_new("container");
1650     }
1651
1652     return internal_root;
1653 }
1654
1655 static void object_get_child_property(Object *obj, Visitor *v,
1656                                       const char *name, void *opaque,
1657                                       Error **errp)
1658 {
1659     Object *child = opaque;
1660     char *path;
1661
1662     path = object_get_canonical_path(child);
1663     visit_type_str(v, name, &path, errp);
1664     g_free(path);
1665 }
1666
1667 static Object *object_resolve_child_property(Object *parent, void *opaque,
1668                                              const char *part)
1669 {
1670     return opaque;
1671 }
1672
1673 static void object_finalize_child_property(Object *obj, const char *name,
1674                                            void *opaque)
1675 {
1676     Object *child = opaque;
1677
1678     if (child->class->unparent) {
1679         (child->class->unparent)(child);
1680     }
1681     child->parent = NULL;
1682     object_unref(child);
1683 }
1684
1685 ObjectProperty *
1686 object_property_try_add_child(Object *obj, const char *name,
1687                               Object *child, Error **errp)
1688 {
1689     g_autofree char *type = NULL;
1690     ObjectProperty *op;
1691
1692     assert(!child->parent);
1693
1694     type = g_strdup_printf("child<%s>", object_get_typename(child));
1695
1696     op = object_property_try_add(obj, name, type, object_get_child_property,
1697                                  NULL, object_finalize_child_property,
1698                                  child, errp);
1699     if (!op) {
1700         return NULL;
1701     }
1702     op->resolve = object_resolve_child_property;
1703     object_ref(child);
1704     child->parent = obj;
1705     return op;
1706 }
1707
1708 ObjectProperty *
1709 object_property_add_child(Object *obj, const char *name,
1710                           Object *child)
1711 {
1712     return object_property_try_add_child(obj, name, child, &error_abort);
1713 }
1714
1715 void object_property_allow_set_link(const Object *obj, const char *name,
1716                                     Object *val, Error **errp)
1717 {
1718     /* Allow the link to be set, always */
1719 }
1720
1721 typedef struct {
1722     union {
1723         Object **targetp;
1724         Object *target; /* if OBJ_PROP_LINK_DIRECT, when holding the pointer  */
1725         ptrdiff_t offset; /* if OBJ_PROP_LINK_CLASS */
1726     };
1727     void (*check)(const Object *, const char *, Object *, Error **);
1728     ObjectPropertyLinkFlags flags;
1729 } LinkProperty;
1730
1731 static Object **
1732 object_link_get_targetp(Object *obj, LinkProperty *lprop)
1733 {
1734     if (lprop->flags & OBJ_PROP_LINK_DIRECT) {
1735         return &lprop->target;
1736     } else if (lprop->flags & OBJ_PROP_LINK_CLASS) {
1737         return (void *)obj + lprop->offset;
1738     } else {
1739         return lprop->targetp;
1740     }
1741 }
1742
1743 static void object_get_link_property(Object *obj, Visitor *v,
1744                                      const char *name, void *opaque,
1745                                      Error **errp)
1746 {
1747     LinkProperty *lprop = opaque;
1748     Object **targetp = object_link_get_targetp(obj, lprop);
1749     char *path;
1750
1751     if (*targetp) {
1752         path = object_get_canonical_path(*targetp);
1753         visit_type_str(v, name, &path, errp);
1754         g_free(path);
1755     } else {
1756         path = (char *)"";
1757         visit_type_str(v, name, &path, errp);
1758     }
1759 }
1760
1761 /*
1762  * object_resolve_link:
1763  *
1764  * Lookup an object and ensure its type matches the link property type.  This
1765  * is similar to object_resolve_path() except type verification against the
1766  * link property is performed.
1767  *
1768  * Returns: The matched object or NULL on path lookup failures.
1769  */
1770 static Object *object_resolve_link(Object *obj, const char *name,
1771                                    const char *path, Error **errp)
1772 {
1773     const char *type;
1774     char *target_type;
1775     bool ambiguous = false;
1776     Object *target;
1777
1778     /* Go from link<FOO> to FOO.  */
1779     type = object_property_get_type(obj, name, NULL);
1780     target_type = g_strndup(&type[5], strlen(type) - 6);
1781     target = object_resolve_path_type(path, target_type, &ambiguous);
1782
1783     if (ambiguous) {
1784         error_setg(errp, "Path '%s' does not uniquely identify an object",
1785                    path);
1786     } else if (!target) {
1787         target = object_resolve_path(path, &ambiguous);
1788         if (target || ambiguous) {
1789             error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type);
1790         } else {
1791             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1792                       "Device '%s' not found", path);
1793         }
1794         target = NULL;
1795     }
1796     g_free(target_type);
1797
1798     return target;
1799 }
1800
1801 static void object_set_link_property(Object *obj, Visitor *v,
1802                                      const char *name, void *opaque,
1803                                      Error **errp)
1804 {
1805     Error *local_err = NULL;
1806     LinkProperty *prop = opaque;
1807     Object **targetp = object_link_get_targetp(obj, prop);
1808     Object *old_target = *targetp;
1809     Object *new_target;
1810     char *path = NULL;
1811
1812     if (!visit_type_str(v, name, &path, errp)) {
1813         return;
1814     }
1815
1816     if (*path) {
1817         new_target = object_resolve_link(obj, name, path, errp);
1818         if (!new_target) {
1819             g_free(path);
1820             return;
1821         }
1822     } else {
1823         new_target = NULL;
1824     }
1825
1826     g_free(path);
1827
1828     prop->check(obj, name, new_target, &local_err);
1829     if (local_err) {
1830         error_propagate(errp, local_err);
1831         return;
1832     }
1833
1834     *targetp = new_target;
1835     if (prop->flags & OBJ_PROP_LINK_STRONG) {
1836         object_ref(new_target);
1837         object_unref(old_target);
1838     }
1839 }
1840
1841 static Object *object_resolve_link_property(Object *parent, void *opaque,
1842                                             const char *part)
1843 {
1844     LinkProperty *lprop = opaque;
1845
1846     return *object_link_get_targetp(parent, lprop);
1847 }
1848
1849 static void object_release_link_property(Object *obj, const char *name,
1850                                          void *opaque)
1851 {
1852     LinkProperty *prop = opaque;
1853     Object **targetp = object_link_get_targetp(obj, prop);
1854
1855     if ((prop->flags & OBJ_PROP_LINK_STRONG) && *targetp) {
1856         object_unref(*targetp);
1857     }
1858     if (!(prop->flags & OBJ_PROP_LINK_CLASS)) {
1859         g_free(prop);
1860     }
1861 }
1862
1863 static ObjectProperty *
1864 object_add_link_prop(Object *obj, const char *name,
1865                      const char *type, void *ptr,
1866                      void (*check)(const Object *, const char *,
1867                                    Object *, Error **),
1868                      ObjectPropertyLinkFlags flags)
1869 {
1870     LinkProperty *prop = g_malloc(sizeof(*prop));
1871     g_autofree char *full_type = NULL;
1872     ObjectProperty *op;
1873
1874     if (flags & OBJ_PROP_LINK_DIRECT) {
1875         prop->target = ptr;
1876     } else {
1877         prop->targetp = ptr;
1878     }
1879     prop->check = check;
1880     prop->flags = flags;
1881
1882     full_type = g_strdup_printf("link<%s>", type);
1883
1884     op = object_property_add(obj, name, full_type,
1885                              object_get_link_property,
1886                              check ? object_set_link_property : NULL,
1887                              object_release_link_property,
1888                              prop);
1889     op->resolve = object_resolve_link_property;
1890     return op;
1891 }
1892
1893 ObjectProperty *
1894 object_property_add_link(Object *obj, const char *name,
1895                          const char *type, Object **targetp,
1896                          void (*check)(const Object *, const char *,
1897                                        Object *, Error **),
1898                          ObjectPropertyLinkFlags flags)
1899 {
1900     return object_add_link_prop(obj, name, type, targetp, check, flags);
1901 }
1902
1903 ObjectProperty *
1904 object_class_property_add_link(ObjectClass *oc,
1905     const char *name,
1906     const char *type, ptrdiff_t offset,
1907     void (*check)(const Object *obj, const char *name,
1908                   Object *val, Error **errp),
1909     ObjectPropertyLinkFlags flags)
1910 {
1911     LinkProperty *prop = g_new0(LinkProperty, 1);
1912     char *full_type;
1913     ObjectProperty *op;
1914
1915     prop->offset = offset;
1916     prop->check = check;
1917     prop->flags = flags | OBJ_PROP_LINK_CLASS;
1918
1919     full_type = g_strdup_printf("link<%s>", type);
1920
1921     op = object_class_property_add(oc, name, full_type,
1922                                    object_get_link_property,
1923                                    check ? object_set_link_property : NULL,
1924                                    object_release_link_property,
1925                                    prop);
1926
1927     op->resolve = object_resolve_link_property;
1928
1929     g_free(full_type);
1930     return op;
1931 }
1932
1933 ObjectProperty *
1934 object_property_add_const_link(Object *obj, const char *name,
1935                                Object *target)
1936 {
1937     return object_add_link_prop(obj, name,
1938                                 object_get_typename(target), target,
1939                                 NULL, OBJ_PROP_LINK_DIRECT);
1940 }
1941
1942 const char *object_get_canonical_path_component(const Object *obj)
1943 {
1944     ObjectProperty *prop = NULL;
1945     GHashTableIter iter;
1946
1947     if (obj->parent == NULL) {
1948         return NULL;
1949     }
1950
1951     g_hash_table_iter_init(&iter, obj->parent->properties);
1952     while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
1953         if (!object_property_is_child(prop)) {
1954             continue;
1955         }
1956
1957         if (prop->opaque == obj) {
1958             return prop->name;
1959         }
1960     }
1961
1962     /* obj had a parent but was not a child, should never happen */
1963     g_assert_not_reached();
1964     return NULL;
1965 }
1966
1967 char *object_get_canonical_path(const Object *obj)
1968 {
1969     Object *root = object_get_root();
1970     char *newpath, *path = NULL;
1971
1972     if (obj == root) {
1973         return g_strdup("/");
1974     }
1975
1976     do {
1977         const char *component = object_get_canonical_path_component(obj);
1978
1979         if (!component) {
1980             /* A canonical path must be complete, so discard what was
1981              * collected so far.
1982              */
1983             g_free(path);
1984             return NULL;
1985         }
1986
1987         newpath = g_strdup_printf("/%s%s", component, path ? path : "");
1988         g_free(path);
1989         path = newpath;
1990         obj = obj->parent;
1991     } while (obj != root);
1992
1993     return path;
1994 }
1995
1996 Object *object_resolve_path_component(Object *parent, const char *part)
1997 {
1998     ObjectProperty *prop = object_property_find(parent, part, NULL);
1999     if (prop == NULL) {
2000         return NULL;
2001     }
2002
2003     if (prop->resolve) {
2004         return prop->resolve(parent, prop->opaque, part);
2005     } else {
2006         return NULL;
2007     }
2008 }
2009
2010 static Object *object_resolve_abs_path(Object *parent,
2011                                           char **parts,
2012                                           const char *typename)
2013 {
2014     Object *child;
2015
2016     if (*parts == NULL) {
2017         return object_dynamic_cast(parent, typename);
2018     }
2019
2020     if (strcmp(*parts, "") == 0) {
2021         return object_resolve_abs_path(parent, parts + 1, typename);
2022     }
2023
2024     child = object_resolve_path_component(parent, *parts);
2025     if (!child) {
2026         return NULL;
2027     }
2028
2029     return object_resolve_abs_path(child, parts + 1, typename);
2030 }
2031
2032 static Object *object_resolve_partial_path(Object *parent,
2033                                            char **parts,
2034                                            const char *typename,
2035                                            bool *ambiguous)
2036 {
2037     Object *obj;
2038     GHashTableIter iter;
2039     ObjectProperty *prop;
2040
2041     obj = object_resolve_abs_path(parent, parts, typename);
2042
2043     g_hash_table_iter_init(&iter, parent->properties);
2044     while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
2045         Object *found;
2046
2047         if (!object_property_is_child(prop)) {
2048             continue;
2049         }
2050
2051         found = object_resolve_partial_path(prop->opaque, parts,
2052                                             typename, ambiguous);
2053         if (found) {
2054             if (obj) {
2055                 *ambiguous = true;
2056                 return NULL;
2057             }
2058             obj = found;
2059         }
2060
2061         if (*ambiguous) {
2062             return NULL;
2063         }
2064     }
2065
2066     return obj;
2067 }
2068
2069 Object *object_resolve_path_type(const char *path, const char *typename,
2070                                  bool *ambiguousp)
2071 {
2072     Object *obj;
2073     char **parts;
2074
2075     parts = g_strsplit(path, "/", 0);
2076     assert(parts);
2077
2078     if (parts[0] == NULL || strcmp(parts[0], "") != 0) {
2079         bool ambiguous = false;
2080         obj = object_resolve_partial_path(object_get_root(), parts,
2081                                           typename, &ambiguous);
2082         if (ambiguousp) {
2083             *ambiguousp = ambiguous;
2084         }
2085     } else {
2086         obj = object_resolve_abs_path(object_get_root(), parts + 1, typename);
2087     }
2088
2089     g_strfreev(parts);
2090
2091     return obj;
2092 }
2093
2094 Object *object_resolve_path(const char *path, bool *ambiguous)
2095 {
2096     return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
2097 }
2098
2099 typedef struct StringProperty
2100 {
2101     char *(*get)(Object *, Error **);
2102     void (*set)(Object *, const char *, Error **);
2103 } StringProperty;
2104
2105 static void property_get_str(Object *obj, Visitor *v, const char *name,
2106                              void *opaque, Error **errp)
2107 {
2108     StringProperty *prop = opaque;
2109     char *value;
2110     Error *err = NULL;
2111
2112     value = prop->get(obj, &err);
2113     if (err) {
2114         error_propagate(errp, err);
2115         return;
2116     }
2117
2118     visit_type_str(v, name, &value, errp);
2119     g_free(value);
2120 }
2121
2122 static void property_set_str(Object *obj, Visitor *v, const char *name,
2123                              void *opaque, Error **errp)
2124 {
2125     StringProperty *prop = opaque;
2126     char *value;
2127
2128     if (!visit_type_str(v, name, &value, errp)) {
2129         return;
2130     }
2131
2132     prop->set(obj, value, errp);
2133     g_free(value);
2134 }
2135
2136 static void property_release_str(Object *obj, const char *name,
2137                                  void *opaque)
2138 {
2139     StringProperty *prop = opaque;
2140     g_free(prop);
2141 }
2142
2143 ObjectProperty *
2144 object_property_add_str(Object *obj, const char *name,
2145                         char *(*get)(Object *, Error **),
2146                         void (*set)(Object *, const char *, Error **))
2147 {
2148     StringProperty *prop = g_malloc0(sizeof(*prop));
2149
2150     prop->get = get;
2151     prop->set = set;
2152
2153     return object_property_add(obj, name, "string",
2154                                get ? property_get_str : NULL,
2155                                set ? property_set_str : NULL,
2156                                property_release_str,
2157                                prop);
2158 }
2159
2160 ObjectProperty *
2161 object_class_property_add_str(ObjectClass *klass, const char *name,
2162                                    char *(*get)(Object *, Error **),
2163                                    void (*set)(Object *, const char *,
2164                                                Error **))
2165 {
2166     StringProperty *prop = g_malloc0(sizeof(*prop));
2167
2168     prop->get = get;
2169     prop->set = set;
2170
2171     return object_class_property_add(klass, name, "string",
2172                                      get ? property_get_str : NULL,
2173                                      set ? property_set_str : NULL,
2174                                      NULL,
2175                                      prop);
2176 }
2177
2178 typedef struct BoolProperty
2179 {
2180     bool (*get)(Object *, Error **);
2181     void (*set)(Object *, bool, Error **);
2182 } BoolProperty;
2183
2184 static void property_get_bool(Object *obj, Visitor *v, const char *name,
2185                               void *opaque, Error **errp)
2186 {
2187     BoolProperty *prop = opaque;
2188     bool value;
2189     Error *err = NULL;
2190
2191     value = prop->get(obj, &err);
2192     if (err) {
2193         error_propagate(errp, err);
2194         return;
2195     }
2196
2197     visit_type_bool(v, name, &value, errp);
2198 }
2199
2200 static void property_set_bool(Object *obj, Visitor *v, const char *name,
2201                               void *opaque, Error **errp)
2202 {
2203     BoolProperty *prop = opaque;
2204     bool value;
2205
2206     if (!visit_type_bool(v, name, &value, errp)) {
2207         return;
2208     }
2209
2210     prop->set(obj, value, errp);
2211 }
2212
2213 static void property_release_bool(Object *obj, const char *name,
2214                                   void *opaque)
2215 {
2216     BoolProperty *prop = opaque;
2217     g_free(prop);
2218 }
2219
2220 ObjectProperty *
2221 object_property_add_bool(Object *obj, const char *name,
2222                          bool (*get)(Object *, Error **),
2223                          void (*set)(Object *, bool, Error **))
2224 {
2225     BoolProperty *prop = g_malloc0(sizeof(*prop));
2226
2227     prop->get = get;
2228     prop->set = set;
2229
2230     return object_property_add(obj, name, "bool",
2231                                get ? property_get_bool : NULL,
2232                                set ? property_set_bool : NULL,
2233                                property_release_bool,
2234                                prop);
2235 }
2236
2237 ObjectProperty *
2238 object_class_property_add_bool(ObjectClass *klass, const char *name,
2239                                     bool (*get)(Object *, Error **),
2240                                     void (*set)(Object *, bool, Error **))
2241 {
2242     BoolProperty *prop = g_malloc0(sizeof(*prop));
2243
2244     prop->get = get;
2245     prop->set = set;
2246
2247     return object_class_property_add(klass, name, "bool",
2248                                      get ? property_get_bool : NULL,
2249                                      set ? property_set_bool : NULL,
2250                                      NULL,
2251                                      prop);
2252 }
2253
2254 static void property_get_enum(Object *obj, Visitor *v, const char *name,
2255                               void *opaque, Error **errp)
2256 {
2257     EnumProperty *prop = opaque;
2258     int value;
2259     Error *err = NULL;
2260
2261     value = prop->get(obj, &err);
2262     if (err) {
2263         error_propagate(errp, err);
2264         return;
2265     }
2266
2267     visit_type_enum(v, name, &value, prop->lookup, errp);
2268 }
2269
2270 static void property_set_enum(Object *obj, Visitor *v, const char *name,
2271                               void *opaque, Error **errp)
2272 {
2273     EnumProperty *prop = opaque;
2274     int value;
2275
2276     if (!visit_type_enum(v, name, &value, prop->lookup, errp)) {
2277         return;
2278     }
2279     prop->set(obj, value, errp);
2280 }
2281
2282 static void property_release_enum(Object *obj, const char *name,
2283                                   void *opaque)
2284 {
2285     EnumProperty *prop = opaque;
2286     g_free(prop);
2287 }
2288
2289 ObjectProperty *
2290 object_property_add_enum(Object *obj, const char *name,
2291                          const char *typename,
2292                          const QEnumLookup *lookup,
2293                          int (*get)(Object *, Error **),
2294                          void (*set)(Object *, int, Error **))
2295 {
2296     EnumProperty *prop = g_malloc(sizeof(*prop));
2297
2298     prop->lookup = lookup;
2299     prop->get = get;
2300     prop->set = set;
2301
2302     return object_property_add(obj, name, typename,
2303                                get ? property_get_enum : NULL,
2304                                set ? property_set_enum : NULL,
2305                                property_release_enum,
2306                                prop);
2307 }
2308
2309 ObjectProperty *
2310 object_class_property_add_enum(ObjectClass *klass, const char *name,
2311                                     const char *typename,
2312                                     const QEnumLookup *lookup,
2313                                     int (*get)(Object *, Error **),
2314                                     void (*set)(Object *, int, Error **))
2315 {
2316     EnumProperty *prop = g_malloc(sizeof(*prop));
2317
2318     prop->lookup = lookup;
2319     prop->get = get;
2320     prop->set = set;
2321
2322     return object_class_property_add(klass, name, typename,
2323                                      get ? property_get_enum : NULL,
2324                                      set ? property_set_enum : NULL,
2325                                      NULL,
2326                                      prop);
2327 }
2328
2329 typedef struct TMProperty {
2330     void (*get)(Object *, struct tm *, Error **);
2331 } TMProperty;
2332
2333 static void property_get_tm(Object *obj, Visitor *v, const char *name,
2334                             void *opaque, Error **errp)
2335 {
2336     TMProperty *prop = opaque;
2337     Error *err = NULL;
2338     struct tm value;
2339
2340     prop->get(obj, &value, &err);
2341     if (err) {
2342         error_propagate(errp, err);
2343         return;
2344     }
2345
2346     if (!visit_start_struct(v, name, NULL, 0, errp)) {
2347         return;
2348     }
2349     if (!visit_type_int32(v, "tm_year", &value.tm_year, errp)) {
2350         goto out_end;
2351     }
2352     if (!visit_type_int32(v, "tm_mon", &value.tm_mon, errp)) {
2353         goto out_end;
2354     }
2355     if (!visit_type_int32(v, "tm_mday", &value.tm_mday, errp)) {
2356         goto out_end;
2357     }
2358     if (!visit_type_int32(v, "tm_hour", &value.tm_hour, errp)) {
2359         goto out_end;
2360     }
2361     if (!visit_type_int32(v, "tm_min", &value.tm_min, errp)) {
2362         goto out_end;
2363     }
2364     if (!visit_type_int32(v, "tm_sec", &value.tm_sec, errp)) {
2365         goto out_end;
2366     }
2367     visit_check_struct(v, errp);
2368 out_end:
2369     visit_end_struct(v, NULL);
2370 }
2371
2372 static void property_release_tm(Object *obj, const char *name,
2373                                 void *opaque)
2374 {
2375     TMProperty *prop = opaque;
2376     g_free(prop);
2377 }
2378
2379 ObjectProperty *
2380 object_property_add_tm(Object *obj, const char *name,
2381                        void (*get)(Object *, struct tm *, Error **))
2382 {
2383     TMProperty *prop = g_malloc0(sizeof(*prop));
2384
2385     prop->get = get;
2386
2387     return object_property_add(obj, name, "struct tm",
2388                                get ? property_get_tm : NULL, NULL,
2389                                property_release_tm,
2390                                prop);
2391 }
2392
2393 ObjectProperty *
2394 object_class_property_add_tm(ObjectClass *klass, const char *name,
2395                              void (*get)(Object *, struct tm *, Error **))
2396 {
2397     TMProperty *prop = g_malloc0(sizeof(*prop));
2398
2399     prop->get = get;
2400
2401     return object_class_property_add(klass, name, "struct tm",
2402                                      get ? property_get_tm : NULL,
2403                                      NULL, NULL, prop);
2404 }
2405
2406 static char *object_get_type(Object *obj, Error **errp)
2407 {
2408     return g_strdup(object_get_typename(obj));
2409 }
2410
2411 static void property_get_uint8_ptr(Object *obj, Visitor *v, const char *name,
2412                                    void *opaque, Error **errp)
2413 {
2414     uint8_t value = *(uint8_t *)opaque;
2415     visit_type_uint8(v, name, &value, errp);
2416 }
2417
2418 static void property_set_uint8_ptr(Object *obj, Visitor *v, const char *name,
2419                                    void *opaque, Error **errp)
2420 {
2421     uint8_t *field = opaque;
2422     uint8_t value;
2423
2424     if (!visit_type_uint8(v, name, &value, errp)) {
2425         return;
2426     }
2427
2428     *field = value;
2429 }
2430
2431 static void property_get_uint16_ptr(Object *obj, Visitor *v, const char *name,
2432                                     void *opaque, Error **errp)
2433 {
2434     uint16_t value = *(uint16_t *)opaque;
2435     visit_type_uint16(v, name, &value, errp);
2436 }
2437
2438 static void property_set_uint16_ptr(Object *obj, Visitor *v, const char *name,
2439                                     void *opaque, Error **errp)
2440 {
2441     uint16_t *field = opaque;
2442     uint16_t value;
2443
2444     if (!visit_type_uint16(v, name, &value, errp)) {
2445         return;
2446     }
2447
2448     *field = value;
2449 }
2450
2451 static void property_get_uint32_ptr(Object *obj, Visitor *v, const char *name,
2452                                     void *opaque, Error **errp)
2453 {
2454     uint32_t value = *(uint32_t *)opaque;
2455     visit_type_uint32(v, name, &value, errp);
2456 }
2457
2458 static void property_set_uint32_ptr(Object *obj, Visitor *v, const char *name,
2459                                     void *opaque, Error **errp)
2460 {
2461     uint32_t *field = opaque;
2462     uint32_t value;
2463
2464     if (!visit_type_uint32(v, name, &value, errp)) {
2465         return;
2466     }
2467
2468     *field = value;
2469 }
2470
2471 static void property_get_uint64_ptr(Object *obj, Visitor *v, const char *name,
2472                                     void *opaque, Error **errp)
2473 {
2474     uint64_t value = *(uint64_t *)opaque;
2475     visit_type_uint64(v, name, &value, errp);
2476 }
2477
2478 static void property_set_uint64_ptr(Object *obj, Visitor *v, const char *name,
2479                                     void *opaque, Error **errp)
2480 {
2481     uint64_t *field = opaque;
2482     uint64_t value;
2483
2484     if (!visit_type_uint64(v, name, &value, errp)) {
2485         return;
2486     }
2487
2488     *field = value;
2489 }
2490
2491 ObjectProperty *
2492 object_property_add_uint8_ptr(Object *obj, const char *name,
2493                               const uint8_t *v,
2494                               ObjectPropertyFlags flags)
2495 {
2496     ObjectPropertyAccessor *getter = NULL;
2497     ObjectPropertyAccessor *setter = NULL;
2498
2499     if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2500         getter = property_get_uint8_ptr;
2501     }
2502
2503     if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2504         setter = property_set_uint8_ptr;
2505     }
2506
2507     return object_property_add(obj, name, "uint8",
2508                                getter, setter, NULL, (void *)v);
2509 }
2510
2511 ObjectProperty *
2512 object_class_property_add_uint8_ptr(ObjectClass *klass, const char *name,
2513                                     const uint8_t *v,
2514                                     ObjectPropertyFlags flags)
2515 {
2516     ObjectPropertyAccessor *getter = NULL;
2517     ObjectPropertyAccessor *setter = NULL;
2518
2519     if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2520         getter = property_get_uint8_ptr;
2521     }
2522
2523     if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2524         setter = property_set_uint8_ptr;
2525     }
2526
2527     return object_class_property_add(klass, name, "uint8",
2528                                      getter, setter, NULL, (void *)v);
2529 }
2530
2531 ObjectProperty *
2532 object_property_add_uint16_ptr(Object *obj, const char *name,
2533                                const uint16_t *v,
2534                                ObjectPropertyFlags flags)
2535 {
2536     ObjectPropertyAccessor *getter = NULL;
2537     ObjectPropertyAccessor *setter = NULL;
2538
2539     if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2540         getter = property_get_uint16_ptr;
2541     }
2542
2543     if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2544         setter = property_set_uint16_ptr;
2545     }
2546
2547     return object_property_add(obj, name, "uint16",
2548                                getter, setter, NULL, (void *)v);
2549 }
2550
2551 ObjectProperty *
2552 object_class_property_add_uint16_ptr(ObjectClass *klass, const char *name,
2553                                      const uint16_t *v,
2554                                      ObjectPropertyFlags flags)
2555 {
2556     ObjectPropertyAccessor *getter = NULL;
2557     ObjectPropertyAccessor *setter = NULL;
2558
2559     if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2560         getter = property_get_uint16_ptr;
2561     }
2562
2563     if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2564         setter = property_set_uint16_ptr;
2565     }
2566
2567     return object_class_property_add(klass, name, "uint16",
2568                                      getter, setter, NULL, (void *)v);
2569 }
2570
2571 ObjectProperty *
2572 object_property_add_uint32_ptr(Object *obj, const char *name,
2573                                const uint32_t *v,
2574                                ObjectPropertyFlags flags)
2575 {
2576     ObjectPropertyAccessor *getter = NULL;
2577     ObjectPropertyAccessor *setter = NULL;
2578
2579     if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2580         getter = property_get_uint32_ptr;
2581     }
2582
2583     if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2584         setter = property_set_uint32_ptr;
2585     }
2586
2587     return object_property_add(obj, name, "uint32",
2588                                getter, setter, NULL, (void *)v);
2589 }
2590
2591 ObjectProperty *
2592 object_class_property_add_uint32_ptr(ObjectClass *klass, const char *name,
2593                                      const uint32_t *v,
2594                                      ObjectPropertyFlags flags)
2595 {
2596     ObjectPropertyAccessor *getter = NULL;
2597     ObjectPropertyAccessor *setter = NULL;
2598
2599     if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2600         getter = property_get_uint32_ptr;
2601     }
2602
2603     if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2604         setter = property_set_uint32_ptr;
2605     }
2606
2607     return object_class_property_add(klass, name, "uint32",
2608                                      getter, setter, NULL, (void *)v);
2609 }
2610
2611 ObjectProperty *
2612 object_property_add_uint64_ptr(Object *obj, const char *name,
2613                                const uint64_t *v,
2614                                ObjectPropertyFlags flags)
2615 {
2616     ObjectPropertyAccessor *getter = NULL;
2617     ObjectPropertyAccessor *setter = NULL;
2618
2619     if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2620         getter = property_get_uint64_ptr;
2621     }
2622
2623     if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2624         setter = property_set_uint64_ptr;
2625     }
2626
2627     return object_property_add(obj, name, "uint64",
2628                                getter, setter, NULL, (void *)v);
2629 }
2630
2631 ObjectProperty *
2632 object_class_property_add_uint64_ptr(ObjectClass *klass, const char *name,
2633                                      const uint64_t *v,
2634                                      ObjectPropertyFlags flags)
2635 {
2636     ObjectPropertyAccessor *getter = NULL;
2637     ObjectPropertyAccessor *setter = NULL;
2638
2639     if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2640         getter = property_get_uint64_ptr;
2641     }
2642
2643     if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2644         setter = property_set_uint64_ptr;
2645     }
2646
2647     return object_class_property_add(klass, name, "uint64",
2648                                      getter, setter, NULL, (void *)v);
2649 }
2650
2651 typedef struct {
2652     Object *target_obj;
2653     char *target_name;
2654 } AliasProperty;
2655
2656 static void property_get_alias(Object *obj, Visitor *v, const char *name,
2657                                void *opaque, Error **errp)
2658 {
2659     AliasProperty *prop = opaque;
2660
2661     object_property_get(prop->target_obj, prop->target_name, v, errp);
2662 }
2663
2664 static void property_set_alias(Object *obj, Visitor *v, const char *name,
2665                                void *opaque, Error **errp)
2666 {
2667     AliasProperty *prop = opaque;
2668
2669     object_property_set(prop->target_obj, prop->target_name, v, errp);
2670 }
2671
2672 static Object *property_resolve_alias(Object *obj, void *opaque,
2673                                       const char *part)
2674 {
2675     AliasProperty *prop = opaque;
2676
2677     return object_resolve_path_component(prop->target_obj, prop->target_name);
2678 }
2679
2680 static void property_release_alias(Object *obj, const char *name, void *opaque)
2681 {
2682     AliasProperty *prop = opaque;
2683
2684     g_free(prop->target_name);
2685     g_free(prop);
2686 }
2687
2688 ObjectProperty *
2689 object_property_add_alias(Object *obj, const char *name,
2690                           Object *target_obj, const char *target_name)
2691 {
2692     AliasProperty *prop;
2693     ObjectProperty *op;
2694     ObjectProperty *target_prop;
2695     g_autofree char *prop_type = NULL;
2696
2697     target_prop = object_property_find(target_obj, target_name,
2698                                        &error_abort);
2699
2700     if (object_property_is_child(target_prop)) {
2701         prop_type = g_strdup_printf("link%s",
2702                                     target_prop->type + strlen("child"));
2703     } else {
2704         prop_type = g_strdup(target_prop->type);
2705     }
2706
2707     prop = g_malloc(sizeof(*prop));
2708     prop->target_obj = target_obj;
2709     prop->target_name = g_strdup(target_name);
2710
2711     op = object_property_add(obj, name, prop_type,
2712                              property_get_alias,
2713                              property_set_alias,
2714                              property_release_alias,
2715                              prop);
2716     op->resolve = property_resolve_alias;
2717     if (target_prop->defval) {
2718         op->defval = qobject_ref(target_prop->defval);
2719     }
2720
2721     object_property_set_description(obj, op->name,
2722                                     target_prop->description);
2723     return op;
2724 }
2725
2726 void object_property_set_description(Object *obj, const char *name,
2727                                      const char *description)
2728 {
2729     ObjectProperty *op;
2730
2731     op = object_property_find(obj, name, &error_abort);
2732     g_free(op->description);
2733     op->description = g_strdup(description);
2734 }
2735
2736 void object_class_property_set_description(ObjectClass *klass,
2737                                            const char *name,
2738                                            const char *description)
2739 {
2740     ObjectProperty *op;
2741
2742     op = g_hash_table_lookup(klass->properties, name);
2743     g_free(op->description);
2744     op->description = g_strdup(description);
2745 }
2746
2747 static void object_class_init(ObjectClass *klass, void *data)
2748 {
2749     object_class_property_add_str(klass, "type", object_get_type,
2750                                   NULL);
2751 }
2752
2753 static void register_types(void)
2754 {
2755     static TypeInfo interface_info = {
2756         .name = TYPE_INTERFACE,
2757         .class_size = sizeof(InterfaceClass),
2758         .abstract = true,
2759     };
2760
2761     static TypeInfo object_info = {
2762         .name = TYPE_OBJECT,
2763         .instance_size = sizeof(Object),
2764         .class_init = object_class_init,
2765         .abstract = true,
2766     };
2767
2768     type_interface = type_register_internal(&interface_info);
2769     type_register_internal(&object_info);
2770 }
2771
2772 type_init(register_types)