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