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