Coverage Report

Created: 2026-10-31 08:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/qom/object.c
Line
Count
Source
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 "qapi/error.h"
15
#include "qom/compat-properties.h"
16
#include "qom/object.h"
17
#include "qom/object_interfaces.h"
18
#include "qemu/cutils.h"
19
#include "qemu/memalign.h"
20
#include "qapi/visitor.h"
21
#include "qapi/string-input-visitor.h"
22
#include "qapi/string-output-visitor.h"
23
#include "qapi/qobject-input-visitor.h"
24
#include "qapi/forward-visitor.h"
25
#include "qapi/qapi-builtin-visit.h"
26
#include "qapi/compat-policy.h"
27
#include "qobject/qdict.h"
28
#include "qobject/qjson.h"
29
#include "qemu/id.h"
30
#include "qapi/qmp/qerror.h"
31
#include "trace.h"
32
33
/* TODO: replace QObject with a simpler visitor to avoid a dependency
34
 * of the QOM core on QObject?  */
35
#include "qom/qom-qobject.h"
36
#include "qobject/qbool.h"
37
#include "qobject/qlist.h"
38
#include "qobject/qnull.h"
39
#include "qobject/qnum.h"
40
#include "qobject/qstring.h"
41
#include "qemu/error-report.h"
42
43
#define MAX_INTERFACES 32
44
45
typedef struct InterfaceImpl InterfaceImpl;
46
typedef struct TypeImpl TypeImpl;
47
48
struct InterfaceImpl
49
{
50
    const char *typename;
51
};
52
53
struct TypeImpl
54
{
55
    const char *name;
56
57
    size_t class_size;
58
59
    size_t instance_size;
60
    size_t instance_align;
61
62
    void (*class_init)(ObjectClass *klass, const void *data);
63
    void (*class_base_init)(ObjectClass *klass, const void *data);
64
65
    const void *class_data;
66
67
    void (*instance_init)(Object *obj);
68
    void (*instance_post_init)(Object *obj);
69
    void (*instance_finalize)(Object *obj);
70
71
    bool abstract;
72
    bool secure;
73
74
    const char *parent;
75
    TypeImpl *parent_type;
76
77
    ObjectClass *class;
78
79
    int num_interfaces;
80
    InterfaceImpl interfaces[MAX_INTERFACES];
81
};
82
83
static Type type_interface;
84
85
static GHashTable *type_table;
86
87
static bool enumerating_types;
88
89
static void type_table_add(TypeImpl *ti)
90
53.3k
{
91
53.3k
    assert(!enumerating_types);
92
53.3k
    g_hash_table_insert(type_table, (void *)ti->name, ti);
93
53.3k
}
94
95
static TypeImpl *type_table_lookup(const char *name)
96
42.2M
{
97
42.2M
    return g_hash_table_lookup(type_table, name);
98
42.2M
}
99
100
static TypeImpl *type_new(const TypeInfo *info)
101
163k
{
102
163k
    TypeImpl *ti = g_malloc0(sizeof(*ti));
103
163k
    int i;
104
105
163k
    g_assert(info->name != NULL);
106
107
163k
    if (type_table_lookup(info->name) != NULL) {
108
0
        fprintf(stderr, "Registering `%s' which already exists\n", info->name);
109
0
        abort();
110
0
    }
111
112
163k
    ti->name = g_strdup(info->name);
113
163k
    ti->parent = g_strdup(info->parent);
114
115
163k
    ti->class_size = info->class_size;
116
163k
    ti->instance_size = info->instance_size;
117
163k
    ti->instance_align = info->instance_align;
118
119
163k
    ti->class_init = info->class_init;
120
163k
    ti->class_base_init = info->class_base_init;
121
163k
    ti->class_data = info->class_data;
122
123
163k
    ti->instance_init = info->instance_init;
124
163k
    ti->instance_post_init = info->instance_post_init;
125
163k
    ti->instance_finalize = info->instance_finalize;
126
127
163k
    ti->abstract = info->abstract;
128
163k
    ti->secure = info->secure;
129
130
182k
    for (i = 0; info->interfaces && info->interfaces[i].type; i++) {
131
18.7k
        ti->interfaces[i].typename = g_strdup(info->interfaces[i].type);
132
18.7k
    }
133
163k
    ti->num_interfaces = i;
134
135
163k
    return ti;
136
163k
}
137
138
static bool type_name_is_valid(const char *name)
139
53.3k
{
140
53.3k
    const int slen = strlen(name);
141
53.3k
    int plen;
142
143
53.3k
    g_assert(slen > 1);
144
145
    /*
146
     * Ideally, the name should start with a letter - however, we've got
147
     * too many names starting with a digit already, so allow digits here,
148
     * too (except '0' which is not used yet)
149
     */
150
53.3k
    if (!g_ascii_isalnum(name[0]) || name[0] == '0') {
151
0
        return false;
152
0
    }
153
154
53.3k
    plen = strspn(name, "abcdefghijklmnopqrstuvwxyz"
155
53.3k
                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
156
53.3k
                        "0123456789-_.");
157
158
53.3k
    return plen == slen;
159
53.3k
}
160
161
static TypeImpl *type_register_internal(const TypeInfo *info)
162
53.3k
{
163
53.3k
    TypeImpl *ti;
164
165
53.3k
    if (!type_name_is_valid(info->name)) {
166
0
        fprintf(stderr, "Registering '%s' with illegal type name\n", info->name);
167
0
        abort();
168
0
    }
169
170
53.3k
    if (info->is_available && !info->is_available()) {
171
0
        return NULL;
172
0
    }
173
174
53.3k
    ti = type_new(info);
175
176
53.3k
    type_table_add(ti);
177
53.3k
    return ti;
178
53.3k
}
179
180
TypeImpl *type_register_static(const TypeInfo *info)
181
53.2k
{
182
53.2k
    assert(info->parent);
183
53.2k
    return type_register_internal(info);
184
53.2k
}
185
186
void type_register_static_array(const TypeInfo *infos, int nr_infos)
187
1.83k
{
188
1.83k
    int i;
189
190
4.63k
    for (i = 0; i < nr_infos; i++) {
191
2.80k
        type_register_static(&infos[i]);
192
2.80k
    }
193
1.83k
}
194
195
static TypeImpl *type_get_by_name_noload(const char *name)
196
42.0M
{
197
42.0M
    if (name == NULL) {
198
0
        return NULL;
199
0
    }
200
201
42.0M
    return type_table_lookup(name);
202
42.0M
}
203
204
static TypeImpl *type_get_or_load_by_name(const char *name, Error **errp)
205
8.07M
{
206
8.07M
    TypeImpl *type = type_get_by_name_noload(name);
207
208
#ifdef CONFIG_MODULES
209
    if (!type) {
210
        int rv = module_load_qom(name, errp);
211
        if (rv > 0) {
212
            type = type_get_by_name_noload(name);
213
        } else {
214
            error_prepend(errp, "could not load a module for type '%s'", name);
215
            return NULL;
216
        }
217
    }
218
#endif
219
8.07M
    if (!type) {
220
28
        error_setg(errp, "unknown type '%s'", name);
221
28
    }
222
223
8.07M
    return type;
224
8.07M
}
225
226
static TypeImpl *type_get_parent(TypeImpl *type)
227
573M
{
228
573M
    if (!type->parent_type && type->parent) {
229
53.2k
        type->parent_type = type_get_by_name_noload(type->parent);
230
53.2k
        if (!type->parent_type) {
231
0
            fprintf(stderr, "Type '%s' is missing its parent '%s'\n",
232
0
                    type->name, type->parent);
233
0
            abort();
234
0
        }
235
53.2k
    }
236
237
573M
    return type->parent_type;
238
573M
}
239
240
static bool type_has_parent(TypeImpl *type)
241
49.8M
{
242
49.8M
    return (type->parent != NULL);
243
49.8M
}
244
245
static size_t type_class_get_size(TypeImpl *ti)
246
322k
{
247
322k
    if (ti->class_size) {
248
163k
        return ti->class_size;
249
163k
    }
250
251
158k
    if (type_has_parent(ti)) {
252
158k
        return type_class_get_size(type_get_parent(ti));
253
158k
    }
254
255
61
    return sizeof(ObjectClass);
256
158k
}
257
258
static size_t type_object_get_size(TypeImpl *ti)
259
644k
{
260
644k
    if (ti->instance_size) {
261
52.2k
        return ti->instance_size;
262
52.2k
    }
263
264
592k
    if (type_has_parent(ti)) {
265
480k
        return type_object_get_size(type_get_parent(ti));
266
480k
    }
267
268
111k
    return 0;
269
592k
}
270
271
static size_t type_object_get_align(TypeImpl *ti)
272
762k
{
273
762k
    if (ti->instance_align) {
274
12.7k
        return ti->instance_align;
275
12.7k
    }
276
277
749k
    if (type_has_parent(ti)) {
278
598k
        return type_object_get_align(type_get_parent(ti));
279
598k
    }
280
281
150k
    return 0;
282
749k
}
283
284
static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type)
285
119M
{
286
119M
    assert(target_type);
287
288
    /* Check if target_type is a direct ancestor of type */
289
473M
    while (type) {
290
420M
        if (type == target_type) {
291
66.6M
            return true;
292
66.6M
        }
293
294
353M
        type = type_get_parent(type);
295
353M
    }
296
297
52.4M
    return false;
298
119M
}
299
300
static void type_initialize(TypeImpl *ti);
301
302
static void type_initialize_interface(TypeImpl *ti, TypeImpl *interface_type,
303
                                      TypeImpl *parent_type)
304
110k
{
305
110k
    InterfaceClass *new_iface;
306
110k
    TypeInfo info = { };
307
110k
    TypeImpl *iface_impl;
308
309
110k
    info.parent = parent_type->name;
310
110k
    info.name = g_strdup_printf("%s::%s", ti->name, interface_type->name);
311
110k
    info.abstract = true;
312
313
110k
    iface_impl = type_new(&info);
314
110k
    iface_impl->parent_type = parent_type;
315
110k
    type_initialize(iface_impl);
316
110k
    g_free((char *)info.name);
317
318
110k
    new_iface = (InterfaceClass *)iface_impl->class;
319
110k
    new_iface->interface_type = interface_type;
320
321
110k
    ti->class->interfaces = g_slist_append(ti->class->interfaces, new_iface);
322
110k
}
323
324
static void object_property_free(gpointer data)
325
32.2M
{
326
32.2M
    ObjectProperty *prop = data;
327
328
32.2M
    if (prop->defval) {
329
11.1k
        qobject_unref(prop->defval);
330
11.1k
        prop->defval = NULL;
331
11.1k
    }
332
32.2M
    g_free(prop->name);
333
32.2M
    g_free(prop->type);
334
32.2M
    g_free(prop->description);
335
32.2M
    g_free(prop);
336
32.2M
}
337
338
static void type_initialize(TypeImpl *ti)
339
128M
{
340
128M
    TypeImpl *parent;
341
342
128M
    if (ti->class) {
343
128M
        return;
344
128M
    }
345
346
163k
    ti->class_size = type_class_get_size(ti);
347
163k
    ti->instance_size = type_object_get_size(ti);
348
163k
    ti->instance_align = type_object_get_align(ti);
349
    /* Any type with zero instance_size is implicitly abstract.
350
     * This means interface types are all abstract.
351
     */
352
163k
    if (ti->instance_size == 0) {
353
111k
        ti->abstract = true;
354
111k
    }
355
163k
    if (type_is_ancestor(ti, type_interface)) {
356
111k
        assert(ti->instance_size == 0);
357
111k
        assert(ti->abstract);
358
111k
        assert(!ti->instance_init);
359
111k
        assert(!ti->instance_post_init);
360
111k
        assert(!ti->instance_finalize);
361
111k
        assert(!ti->num_interfaces);
362
111k
    }
363
163k
    ti->class = g_malloc0(ti->class_size);
364
365
163k
    parent = type_get_parent(ti);
366
163k
    if (parent) {
367
163k
        type_initialize(parent);
368
163k
        GSList *e;
369
163k
        int i;
370
371
163k
        g_assert(parent->class_size <= ti->class_size);
372
163k
        g_assert(parent->instance_size <= ti->instance_size);
373
163k
        memcpy(ti->class, parent->class, parent->class_size);
374
163k
        ti->class->interfaces = NULL;
375
376
254k
        for (e = parent->class->interfaces; e; e = e->next) {
377
91.5k
            InterfaceClass *iface = e->data;
378
91.5k
            ObjectClass *klass = OBJECT_CLASS(iface);
379
380
91.5k
            type_initialize_interface(ti, iface->interface_type, klass->type);
381
91.5k
        }
382
383
182k
        for (i = 0; i < ti->num_interfaces; i++) {
384
18.7k
            TypeImpl *t = type_get_by_name_noload(ti->interfaces[i].typename);
385
18.7k
            if (!t) {
386
0
                error_report("missing interface '%s' for object '%s'",
387
0
                             ti->interfaces[i].typename, parent->name);
388
0
                abort();
389
0
            }
390
57.8k
            for (e = ti->class->interfaces; e; e = e->next) {
391
39.2k
                TypeImpl *target_type = OBJECT_CLASS(e->data)->type;
392
393
39.2k
                if (type_is_ancestor(target_type, t)) {
394
122
                    break;
395
122
                }
396
39.2k
            }
397
398
18.7k
            if (e) {
399
122
                continue;
400
122
            }
401
402
18.6k
            type_initialize_interface(ti, t, t);
403
18.6k
        }
404
163k
    }
405
406
163k
    ti->class->properties = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
407
163k
                                                  object_property_free);
408
409
163k
    ti->class->type = ti;
410
411
799k
    while (parent) {
412
635k
        if (parent->class_base_init) {
413
56.3k
            parent->class_base_init(ti->class, ti->class_data);
414
56.3k
        }
415
635k
        parent = type_get_parent(parent);
416
635k
    }
417
418
163k
    if (ti->class_init) {
419
47.5k
        ti->class_init(ti->class, ti->class_data);
420
47.5k
    }
421
163k
}
422
423
static void object_init_with_type(Object *obj, TypeImpl *ti)
424
16.1M
{
425
16.1M
    if (type_has_parent(ti)) {
426
8.08M
        object_init_with_type(obj, type_get_parent(ti));
427
8.08M
    }
428
429
16.1M
    if (ti->instance_init) {
430
8.06M
        ti->instance_init(obj);
431
8.06M
    }
432
16.1M
}
433
434
static void object_post_init_with_type(Object *obj, TypeImpl *ti)
435
16.1M
{
436
16.1M
    if (type_has_parent(ti)) {
437
8.08M
        object_post_init_with_type(obj, type_get_parent(ti));
438
8.08M
    }
439
440
16.1M
    if (ti->instance_post_init) {
441
4.37k
        ti->instance_post_init(obj);
442
4.37k
    }
443
16.1M
}
444
445
bool object_apply_global_props(Object *obj, const GPtrArray *props,
446
                               Error **errp)
447
17.3k
{
448
17.3k
    int i;
449
450
17.3k
    if (!props) {
451
8.75k
        return true;
452
8.75k
    }
453
454
21.1k
    for (i = 0; i < props->len; i++) {
455
12.5k
        GlobalProperty *p = g_ptr_array_index(props, i);
456
12.5k
        Error *err = NULL;
457
458
12.5k
        if (object_dynamic_cast(obj, p->driver) == NULL) {
459
12.5k
            continue;
460
12.5k
        }
461
0
        if (p->optional && !object_property_find(obj, p->property)) {
462
0
            continue;
463
0
        }
464
0
        p->used = true;
465
0
        if (!object_property_parse(obj, p->property, p->value, &err)) {
466
0
            error_prepend(&err, "can't apply global %s.%s=%s: ",
467
0
                          p->driver, p->property, p->value);
468
            /*
469
             * If errp != NULL, propagate error and return.
470
             * If errp == NULL, report a warning, but keep going
471
             * with the remaining globals.
472
             */
473
0
            if (errp) {
474
0
                error_propagate(errp, err);
475
0
                return false;
476
0
            } else {
477
0
                warn_report_err(err);
478
0
            }
479
0
        }
480
0
    }
481
482
8.61k
    return true;
483
8.61k
}
484
485
static void object_class_property_init_all(Object *obj)
486
8.07M
{
487
8.07M
    ObjectPropertyIterator iter;
488
8.07M
    ObjectProperty *prop;
489
490
8.07M
    object_class_property_iter_init(&iter, object_get_class(obj));
491
16.2M
    while ((prop = object_property_iter_next(&iter))) {
492
8.17M
        if (prop->init) {
493
48.6k
            prop->init(obj, prop);
494
48.6k
        }
495
8.17M
    }
496
8.07M
}
497
498
static void object_initialize_with_type(Object *obj, size_t size, TypeImpl *type)
499
8.07M
{
500
8.07M
    type_initialize(type);
501
502
8.07M
    g_assert(type->instance_size >= sizeof(Object));
503
8.07M
    g_assert(type->abstract == false);
504
8.07M
    g_assert(size >= type->instance_size);
505
506
8.07M
    memset(obj, 0, type->instance_size);
507
8.07M
    obj->class = type->class;
508
8.07M
    object_ref(obj);
509
8.07M
    object_class_property_init_all(obj);
510
8.07M
    obj->properties = g_hash_table_new_full(g_str_hash, g_str_equal,
511
8.07M
                                            NULL, object_property_free);
512
8.07M
    object_init_with_type(obj, type);
513
8.07M
    object_post_init_with_type(obj, type);
514
8.07M
}
515
516
void object_initialize(void *data, size_t size, const char *typename)
517
8.05M
{
518
8.05M
    TypeImpl *type = type_get_or_load_by_name(typename, &error_fatal);
519
520
8.05M
    object_initialize_with_type(data, size, type);
521
8.05M
}
522
523
bool object_initialize_child_with_props(Object *parentobj,
524
                                        const char *propname,
525
                                        void *childobj, size_t size,
526
                                        const char *type,
527
                                        Error **errp, ...)
528
640
{
529
640
    va_list vargs;
530
640
    bool ok;
531
532
640
    va_start(vargs, errp);
533
640
    ok = object_initialize_child_with_propsv(parentobj, propname,
534
640
                                             childobj, size, type, errp,
535
640
                                             vargs);
536
640
    va_end(vargs);
537
640
    return ok;
538
640
}
539
540
bool object_initialize_child_with_propsv(Object *parentobj,
541
                                         const char *propname,
542
                                         void *childobj, size_t size,
543
                                         const char *type,
544
                                         Error **errp, va_list vargs)
545
640
{
546
640
    bool ok = false;
547
640
    Object *obj;
548
640
    UserCreatable *uc;
549
550
640
    object_initialize(childobj, size, type);
551
640
    obj = OBJECT(childobj);
552
553
640
    if (!object_set_propv(obj, vargs, errp)) {
554
0
        goto out;
555
0
    }
556
557
640
    object_property_add_child(parentobj, propname, obj);
558
559
640
    uc = (UserCreatable *)object_dynamic_cast(obj, TYPE_USER_CREATABLE);
560
640
    if (uc) {
561
0
        if (!user_creatable_complete(uc, errp)) {
562
0
            object_unparent(obj);
563
0
            goto out;
564
0
        }
565
0
    }
566
567
640
    ok = true;
568
569
640
out:
570
    /*
571
     * We want @obj's reference to be 1 on success, 0 on failure.
572
     * On success, it's 2: one taken by object_initialize(), and one
573
     * by object_property_add_child().
574
     * On failure in object_initialize() or earlier, it's 1.
575
     * On failure afterwards, it's also 1: object_unparent() releases
576
     * the reference taken by object_property_add_child().
577
     */
578
640
    object_unref(obj);
579
640
    return ok;
580
640
}
581
582
void object_initialize_child_internal(Object *parent,
583
                                      const char *propname,
584
                                      void *child, size_t size,
585
                                      const char *type)
586
436
{
587
436
    object_initialize_child_with_props(parent, propname, child, size, type,
588
436
                                       &error_abort, NULL);
589
436
}
590
591
static inline bool object_property_is_child(ObjectProperty *prop)
592
3.31M
{
593
3.31M
    return strstart(prop->type, "child<", NULL);
594
3.31M
}
595
596
static void object_property_del_all(Object *obj)
597
8.04M
{
598
8.04M
    g_autoptr(GHashTable) done = g_hash_table_new(NULL, NULL);
599
8.04M
    ObjectProperty *prop;
600
8.04M
    ObjectPropertyIterator iter;
601
8.04M
    bool released;
602
603
16.1M
    do {
604
16.1M
        released = false;
605
16.1M
        object_property_iter_init(&iter, obj);
606
81.0M
        while ((prop = object_property_iter_next(&iter)) != NULL) {
607
73.0M
            if (g_hash_table_add(done, prop)) {
608
40.2M
                trace_object_property_del(obj, obj->class->type->name,
609
40.2M
                                          prop->name, prop->opaque);
610
40.2M
                if (prop->release) {
611
8.06M
                    prop->release(obj, prop->name, prop->opaque);
612
8.06M
                    released = true;
613
8.06M
                    break;
614
8.06M
                }
615
40.2M
            }
616
73.0M
        }
617
16.1M
    } while (released);
618
619
8.04M
    g_hash_table_unref(obj->properties);
620
8.04M
}
621
622
static void object_property_del_child(Object *obj, Object *child)
623
61.1k
{
624
61.1k
    ObjectProperty *prop;
625
61.1k
    GHashTableIter iter;
626
61.1k
    gpointer key, value;
627
628
61.1k
    trace_object_property_del_child(obj, obj->class->type->name,
629
61.1k
                                    child, child->class->type->name);
630
61.1k
    g_hash_table_iter_init(&iter, obj->properties);
631
910k
    while (g_hash_table_iter_next(&iter, &key, &value)) {
632
910k
        prop = value;
633
910k
        if (object_property_is_child(prop) && prop->opaque == child) {
634
61.1k
            trace_object_property_del(obj, obj->class->type->name,
635
61.1k
                                      prop->name, prop->opaque);
636
61.1k
            if (prop->release) {
637
61.1k
                prop->release(obj, prop->name, prop->opaque);
638
61.1k
                prop->release = NULL;
639
61.1k
            }
640
61.1k
            break;
641
61.1k
        }
642
910k
    }
643
61.1k
    g_hash_table_iter_init(&iter, obj->properties);
644
910k
    while (g_hash_table_iter_next(&iter, &key, &value)) {
645
910k
        prop = value;
646
910k
        if (object_property_is_child(prop) && prop->opaque == child) {
647
61.1k
            g_hash_table_iter_remove(&iter);
648
61.1k
            break;
649
61.1k
        }
650
910k
    }
651
61.1k
}
652
653
void object_unparent(Object *obj)
654
61.1k
{
655
61.1k
    if (obj->parent) {
656
61.1k
        object_property_del_child(obj->parent, obj);
657
61.1k
    }
658
61.1k
}
659
660
static void object_deinit(Object *obj, TypeImpl *type)
661
16.0M
{
662
16.0M
    if (type->instance_finalize) {
663
8.04M
        type->instance_finalize(obj);
664
8.04M
    }
665
666
16.0M
    if (type_has_parent(type)) {
667
8.04M
        object_deinit(obj, type_get_parent(type));
668
8.04M
    }
669
16.0M
}
670
671
static void object_finalize(void *data)
672
8.04M
{
673
8.04M
    Object *obj = data;
674
8.04M
    TypeImpl *ti = obj->class->type;
675
8.04M
    trace_object_finalize(obj, obj->class->type->name);
676
8.04M
    object_property_del_all(obj);
677
8.04M
    object_deinit(obj, ti);
678
679
8.04M
    g_assert(obj->ref == 0);
680
8.04M
    g_assert(obj->parent == NULL);
681
8.04M
    if (obj->free) {
682
1.64k
        obj->free(obj);
683
1.64k
    }
684
8.04M
}
685
686
static Object *object_new_with_type(Type type)
687
11.2k
{
688
11.2k
    Object *obj;
689
11.2k
    size_t size, align;
690
11.2k
    void (*obj_free)(void *);
691
692
11.2k
    g_assert(type != NULL);
693
11.2k
    type_initialize(type);
694
695
11.2k
    size = type->instance_size;
696
11.2k
    align = type->instance_align;
697
698
    /*
699
     * Do not use qemu_memalign unless required.  Depending on the
700
     * implementation, extra alignment implies extra overhead.
701
     */
702
11.2k
    if (likely(align <= __alignof__(max_align_t))) {
703
11.2k
        obj = g_malloc(size);
704
11.2k
        obj_free = g_free;
705
11.2k
    } else {
706
0
        obj = qemu_memalign(align, size);
707
0
        obj_free = qemu_vfree;
708
0
    }
709
710
11.2k
    object_initialize_with_type(obj, size, type);
711
11.2k
    obj->free = obj_free;
712
713
11.2k
    trace_object_new(obj, obj->class->type->name);
714
11.2k
    return obj;
715
11.2k
}
716
717
Object *object_new_with_class(ObjectClass *klass)
718
1.95k
{
719
1.95k
    return object_new_with_type(klass->type);
720
1.95k
}
721
722
Object *object_new(const char *typename)
723
9.29k
{
724
9.29k
    TypeImpl *ti = type_get_or_load_by_name(typename, &error_fatal);
725
726
9.29k
    return object_new_with_type(ti);
727
9.29k
}
728
729
730
Object *object_new_with_props(const char *typename,
731
                              Object *parent,
732
                              const char *id,
733
                              Error **errp,
734
                              ...)
735
5
{
736
5
    va_list vargs;
737
5
    Object *obj;
738
739
5
    assert(parent != NULL);
740
5
    assert(id != NULL);
741
5
    va_start(vargs, errp);
742
5
    obj = object_new_with_propv(typename, parent, id, vargs, errp);
743
5
    va_end(vargs);
744
745
5
    return obj;
746
5
}
747
748
749
static Object *
750
object_new_with_props_helper(const char *typename,
751
                             Object *parent,
752
                             const char *id,
753
                             void *props,
754
                             bool (set_props)(Object *obj, void *props,
755
                                              Error **errp),
756
                             Error **errp)
757
5
{
758
5
    ERRP_GUARD();
759
5
    Object *obj;
760
5
    ObjectClass *klass;
761
5
    UserCreatable *uc;
762
763
5
    assert((id != NULL && parent != NULL) ||
764
5
           (id == NULL && parent == NULL));
765
766
5
    if (id != NULL && !id_wellformed(id)) {
767
0
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");
768
0
        error_append_hint(errp, "Identifiers consist of letters, digits, "
769
0
                          "'-', '.', '_', starting with a letter.\n");
770
0
        return NULL;
771
0
    }
772
773
5
    klass = module_object_class_by_name(typename);
774
5
    if (!klass) {
775
0
        error_setg(errp, "invalid object type: %s", typename);
776
0
        return NULL;
777
0
    }
778
779
5
    if (object_class_is_abstract(klass)) {
780
0
        error_setg(errp, "object type '%s' is abstract", typename);
781
0
        return NULL;
782
0
    }
783
5
    obj = object_new_with_type(klass->type);
784
785
5
    if (!set_props(obj, props, errp)) {
786
0
        goto error;
787
0
    }
788
789
5
    if (id != NULL) {
790
5
        object_property_try_add_child(parent, id, obj, errp);
791
5
        if (*errp) {
792
0
            goto error;
793
0
        }
794
5
    }
795
796
5
    uc = (UserCreatable *)object_dynamic_cast(obj, TYPE_USER_CREATABLE);
797
5
    if (uc) {
798
5
        if (!user_creatable_complete(uc, errp)) {
799
0
            if (id != NULL) {
800
0
                object_unparent(obj);
801
0
            }
802
0
            goto error;
803
0
        }
804
5
    }
805
806
5
    return obj;
807
808
0
 error:
809
0
    object_unref(obj);
810
0
    return NULL;
811
5
}
812
813
struct ObjectNewVargsData {
814
    va_list vargs;
815
};
816
817
static bool object_new_with_propv_setter(Object *obj,
818
                                         void *props,
819
                                         Error **errp)
820
5
{
821
5
    struct ObjectNewVargsData *data = props;
822
5
    return object_set_propv(obj, data->vargs, errp);
823
5
}
824
825
Object *object_new_with_propv(const char *typename,
826
                              Object *parent,
827
                              const char *id,
828
                              va_list vargs,
829
                              Error **errp)
830
5
{
831
5
    Object *obj;
832
5
    struct ObjectNewVargsData data;
833
5
    assert(parent != NULL);
834
5
    assert(id != NULL);
835
5
    va_copy(data.vargs, vargs);
836
5
    obj = object_new_with_props_helper(typename,
837
5
                                       parent,
838
5
                                       id,
839
5
                                       &data,
840
5
                                       object_new_with_propv_setter,
841
5
                                       errp);
842
5
    va_end(data.vargs);
843
5
    if (obj) {
844
5
        object_unref(obj);
845
5
    }
846
5
    return obj;
847
5
}
848
849
struct ObjectNewQDictData {
850
    const QDict *props;
851
    Visitor *v;
852
};
853
854
static bool object_new_with_qdict_setter(Object *obj,
855
                                         void *props,
856
                                         Error **errp)
857
0
{
858
0
    struct ObjectNewQDictData *data = props;
859
0
    return object_set_props_from_qdict(obj, data->props, data->v, errp);
860
0
}
861
862
Object *object_new_with_props_from_qdict(const char *typename,
863
                                         Object *parent,
864
                                         const char *id,
865
                                         const QDict *props,
866
                                         Visitor *v,
867
                                         Error **errp)
868
0
{
869
0
    struct ObjectNewQDictData data = { props, v };
870
0
    Object *obj;
871
0
    assert(parent != NULL);
872
0
    assert(id != NULL);
873
0
    obj = object_new_with_props_helper(typename,
874
0
                                       parent,
875
0
                                       id,
876
0
                                       &data,
877
0
                                       object_new_with_qdict_setter,
878
0
                                       errp);
879
0
    if (obj) {
880
0
        object_unref(obj);
881
0
    }
882
0
    return obj;
883
0
}
884
885
Object *object_new_with_props_parentless(const char *typename,
886
                                         Error **errp,
887
                                         ...)
888
0
{
889
0
    va_list vargs;
890
0
    Object *obj;
891
892
0
    va_start(vargs, errp);
893
0
    obj = object_new_with_propv_parentless(typename, vargs, errp);
894
0
    va_end(vargs);
895
896
0
    return obj;
897
0
}
898
899
Object *object_new_with_propv_parentless(const char *typename,
900
                                         va_list vargs,
901
                                         Error **errp)
902
0
{
903
0
    Object *ret;
904
0
    struct ObjectNewVargsData data;
905
0
    va_copy(data.vargs, vargs);
906
0
    ret = object_new_with_props_helper(typename, NULL, NULL, &data,
907
0
                                       object_new_with_propv_setter, errp);
908
0
    va_end(data.vargs);
909
0
    return ret;
910
0
}
911
912
Object *object_new_with_props_from_qdict_parentless(const char *typename,
913
                                                    const QDict *props,
914
                                                    Visitor *v,
915
                                                    Error **errp)
916
0
{
917
0
    struct ObjectNewQDictData data = { props, v };
918
0
    return object_new_with_props_helper(typename, NULL, NULL, &data,
919
0
                                        object_new_with_qdict_setter, errp);
920
0
}
921
922
bool object_set_props(Object *obj,
923
                      Error **errp,
924
                      ...)
925
0
{
926
0
    va_list vargs;
927
0
    bool ret;
928
929
0
    va_start(vargs, errp);
930
0
    ret = object_set_propv(obj, vargs, errp);
931
0
    va_end(vargs);
932
933
0
    return ret;
934
0
}
935
936
937
bool object_set_propv(Object *obj,
938
                      va_list vargs,
939
                      Error **errp)
940
645
{
941
645
    const char *propname;
942
943
645
    propname = va_arg(vargs, char *);
944
655
    while (propname != NULL) {
945
10
        const char *value = va_arg(vargs, char *);
946
947
10
        g_assert(value != NULL);
948
10
        if (!object_property_parse(obj, propname, value, errp)) {
949
0
            return false;
950
0
        }
951
10
        propname = va_arg(vargs, char *);
952
10
    }
953
954
645
    return true;
955
645
}
956
957
bool object_set_props_from_qdict(Object *obj, const QDict *qdict,
958
                                 Visitor *v, Error **errp)
959
223
{
960
223
    ERRP_GUARD();
961
223
    const QDictEntry *e;
962
963
223
    if (!visit_start_struct(v, NULL, NULL, 0, errp)) {
964
0
        return false;
965
0
    }
966
436
    for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) {
967
213
        if (!object_property_set(obj, e->key, v, errp)) {
968
0
            goto out;
969
0
        }
970
213
    }
971
223
    visit_check_struct(v, errp);
972
223
out:
973
223
    visit_end_struct(v, NULL);
974
975
223
    return *errp == NULL;
976
223
}
977
978
bool object_set_props_from_keyval(Object *obj, const QDict *qdict,
979
                                  bool from_json, Error **errp)
980
223
{
981
223
    bool ret;
982
223
    Visitor *v;
983
223
    if (from_json) {
984
0
        v = qobject_input_visitor_new(QOBJECT(qdict));
985
223
    } else {
986
223
        v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
987
223
    }
988
223
    ret = object_set_props_from_qdict(obj, qdict, v, errp);
989
223
    visit_free(v);
990
223
    return ret;
991
223
}
992
993
Object *object_dynamic_cast(Object *obj, const char *typename)
994
8.57M
{
995
8.57M
    if (obj && object_class_dynamic_cast(object_get_class(obj), typename)) {
996
104k
        return obj;
997
104k
    }
998
999
8.47M
    return NULL;
1000
8.57M
}
1001
1002
Object *object_dynamic_cast_assert(Object *obj, const char *typename,
1003
                                   const char *file, int line, const char *func)
1004
221M
{
1005
221M
    trace_object_dynamic_cast_assert(
1006
221M
        obj, obj ? obj->class->type->name : "(null)",
1007
221M
        typename, file, line, func);
1008
1009
221M
#ifdef CONFIG_QOM_CAST_DEBUG
1010
221M
    int i;
1011
221M
    Object *inst;
1012
1013
665M
    for (i = 0; obj && i < OBJECT_CLASS_CAST_CACHE; i++) {
1014
1.33G
        if (qatomic_read(&obj->class->object_cast_cache[i]) == typename) {
1015
221M
            goto out;
1016
221M
        }
1017
665M
    }
1018
1019
28.9k
    inst = object_dynamic_cast(obj, typename);
1020
1021
28.9k
    if (!inst && obj) {
1022
0
        fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
1023
0
                file, line, func, obj, typename);
1024
0
        abort();
1025
0
    }
1026
1027
28.9k
    assert(obj == inst);
1028
1029
28.9k
    if (obj && obj == inst) {
1030
54.3k
        for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
1031
40.7k
            qatomic_set(&obj->class->object_cast_cache[i - 1],
1032
40.7k
                       qatomic_read(&obj->class->object_cast_cache[i]));
1033
40.7k
        }
1034
13.5k
        qatomic_set(&obj->class->object_cast_cache[i - 1], typename);
1035
13.5k
    }
1036
1037
221M
out:
1038
221M
#endif
1039
221M
    return obj;
1040
28.9k
}
1041
1042
ObjectClass *object_class_dynamic_cast(ObjectClass *class,
1043
                                       const char *typename)
1044
33.9M
{
1045
33.9M
    ObjectClass *ret = NULL;
1046
33.9M
    TypeImpl *target_type;
1047
33.9M
    TypeImpl *type;
1048
1049
33.9M
    if (!class) {
1050
0
        return NULL;
1051
0
    }
1052
1053
    /* A simple fast path that can trigger a lot for leaf classes.  */
1054
33.9M
    type = class->type;
1055
33.9M
    if (type->name == typename) {
1056
0
        return class;
1057
0
    }
1058
1059
33.9M
    target_type = type_get_by_name_noload(typename);
1060
33.9M
    if (!target_type) {
1061
        /* target class type unknown, so fail the cast */
1062
5
        return NULL;
1063
5
    }
1064
1065
33.9M
    if (type->class->interfaces &&
1066
33.6M
            type_is_ancestor(target_type, type_interface)) {
1067
33.2M
        int found = 0;
1068
33.2M
        GSList *i;
1069
1070
117M
        for (i = class->interfaces; i; i = i->next) {
1071
84.5M
            ObjectClass *target_class = i->data;
1072
1073
84.5M
            if (type_is_ancestor(target_class->type, target_type)) {
1074
33.1M
                ret = target_class;
1075
33.1M
                found++;
1076
33.1M
            }
1077
84.5M
         }
1078
1079
        /* The match was ambiguous, don't allow a cast */
1080
33.2M
        if (found > 1) {
1081
0
            ret = NULL;
1082
0
        }
1083
33.2M
    } else if (type_is_ancestor(type, target_type)) {
1084
131k
        ret = class;
1085
131k
    }
1086
1087
33.9M
    return ret;
1088
33.9M
}
1089
1090
ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class,
1091
                                              const char *typename,
1092
                                              const char *file, int line,
1093
                                              const char *func)
1094
139M
{
1095
139M
    ObjectClass *ret;
1096
1097
139M
    trace_object_class_dynamic_cast_assert(
1098
139M
        class ? class->type->name : "(null)",
1099
139M
        typename, file, line, func);
1100
1101
139M
#ifdef CONFIG_QOM_CAST_DEBUG
1102
139M
    int i;
1103
1104
549M
    for (i = 0; class && i < OBJECT_CLASS_CAST_CACHE; i++) {
1105
1.03G
        if (qatomic_read(&class->class_cast_cache[i]) == typename) {
1106
105M
            ret = class;
1107
105M
            goto out;
1108
105M
        }
1109
516M
    }
1110
#else
1111
    if (!class || !class->interfaces) {
1112
        return class;
1113
    }
1114
#endif
1115
1116
33.1M
    ret = object_class_dynamic_cast(class, typename);
1117
33.1M
    if (!ret && class) {
1118
0
        fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
1119
0
                file, line, func, class, typename);
1120
0
        abort();
1121
0
    }
1122
1123
33.1M
#ifdef CONFIG_QOM_CAST_DEBUG
1124
33.1M
    if (class && ret == class) {
1125
64.1k
        for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
1126
48.1k
            qatomic_set(&class->class_cast_cache[i - 1],
1127
48.1k
                       qatomic_read(&class->class_cast_cache[i]));
1128
48.1k
        }
1129
16.0k
        qatomic_set(&class->class_cast_cache[i - 1], typename);
1130
16.0k
    }
1131
139M
out:
1132
139M
#endif
1133
139M
    return ret;
1134
33.1M
}
1135
1136
const char *object_get_typename(const Object *obj)
1137
15.9M
{
1138
15.9M
    return obj->class->type->name;
1139
15.9M
}
1140
1141
ObjectClass *object_get_class(Object *obj)
1142
219M
{
1143
219M
    return obj->class;
1144
219M
}
1145
1146
bool object_class_is_abstract(ObjectClass *klass)
1147
17.1k
{
1148
17.1k
    return klass->type->abstract;
1149
17.1k
}
1150
1151
bool object_class_is_secure(ObjectClass *klass)
1152
223
{
1153
223
    return klass->type->secure;
1154
223
}
1155
1156
const char *object_class_get_name(ObjectClass *klass)
1157
139k
{
1158
139k
    return klass->type->name;
1159
139k
}
1160
1161
ObjectClass *object_class_by_name(const char *typename)
1162
488
{
1163
488
    TypeImpl *type = type_get_by_name_noload(typename);
1164
1165
488
    if (!type) {
1166
122
        return NULL;
1167
122
    }
1168
1169
366
    type_initialize(type);
1170
1171
366
    return type->class;
1172
488
}
1173
1174
ObjectClass *module_object_class_by_name(const char *typename)
1175
4.05k
{
1176
4.05k
    TypeImpl *type = type_get_or_load_by_name(typename, NULL);
1177
1178
4.05k
    if (!type) {
1179
28
        return NULL;
1180
28
    }
1181
1182
4.02k
    type_initialize(type);
1183
1184
4.02k
    return type->class;
1185
4.05k
}
1186
1187
ObjectClass *object_class_get_parent(ObjectClass *class)
1188
192M
{
1189
192M
    TypeImpl *type = type_get_parent(class->type);
1190
1191
192M
    if (!type) {
1192
72.5M
        return NULL;
1193
72.5M
    }
1194
1195
120M
    type_initialize(type);
1196
1197
120M
    return type->class;
1198
192M
}
1199
1200
typedef struct OCFData
1201
{
1202
    void (*fn)(ObjectClass *klass, void *opaque);
1203
    const char *implements_type;
1204
    bool include_abstract;
1205
    void *opaque;
1206
} OCFData;
1207
1208
static void object_class_foreach_tramp(gpointer key, gpointer value,
1209
                                       gpointer opaque)
1210
160k
{
1211
160k
    OCFData *data = opaque;
1212
160k
    TypeImpl *type = value;
1213
160k
    ObjectClass *k;
1214
1215
160k
    type_initialize(type);
1216
160k
    k = type->class;
1217
1218
160k
    if (!data->include_abstract && type->abstract) {
1219
29.2k
        return;
1220
29.2k
    }
1221
1222
130k
    if (data->implements_type && 
1223
130k
        !object_class_dynamic_cast(k, data->implements_type)) {
1224
117k
        return;
1225
117k
    }
1226
1227
13.2k
    data->fn(k, data->opaque);
1228
13.2k
}
1229
1230
void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
1231
                          const char *implements_type, bool include_abstract,
1232
                          void *opaque)
1233
244
{
1234
244
    OCFData data = { fn, implements_type, include_abstract, opaque };
1235
1236
244
    enumerating_types = true;
1237
244
    g_hash_table_foreach(type_table, object_class_foreach_tramp, &data);
1238
244
    enumerating_types = false;
1239
244
}
1240
1241
static int do_object_child_foreach(Object *obj,
1242
                                   int (*fn)(Object *child, void *opaque),
1243
                                   void *opaque, bool recurse)
1244
26.9k
{
1245
26.9k
    GHashTableIter iter;
1246
26.9k
    ObjectProperty *prop;
1247
26.9k
    int ret = 0;
1248
1249
26.9k
    g_hash_table_iter_init(&iter, obj->properties);
1250
125k
    while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
1251
98.6k
        if (object_property_is_child(prop)) {
1252
30.2k
            Object *child = prop->opaque;
1253
1254
30.2k
            ret = fn(child, opaque);
1255
30.2k
            if (ret != 0) {
1256
0
                break;
1257
0
            }
1258
30.2k
            if (recurse) {
1259
26.5k
                ret = do_object_child_foreach(child, fn, opaque, true);
1260
26.5k
                if (ret != 0) {
1261
0
                    break;
1262
0
                }
1263
26.5k
            }
1264
30.2k
        }
1265
98.6k
    }
1266
26.9k
    return ret;
1267
26.9k
}
1268
1269
int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
1270
                         void *opaque)
1271
244
{
1272
244
    return do_object_child_foreach(obj, fn, opaque, false);
1273
244
}
1274
1275
int object_child_foreach_recursive(Object *obj,
1276
                                   int (*fn)(Object *child, void *opaque),
1277
                                   void *opaque)
1278
177
{
1279
177
    return do_object_child_foreach(obj, fn, opaque, true);
1280
177
}
1281
1282
static void object_class_get_list_tramp(ObjectClass *klass, void *opaque)
1283
13.2k
{
1284
13.2k
    GSList **list = opaque;
1285
1286
13.2k
    *list = g_slist_prepend(*list, klass);
1287
13.2k
}
1288
1289
GSList *object_class_get_list(const char *implements_type,
1290
                              bool include_abstract)
1291
244
{
1292
244
    GSList *list = NULL;
1293
1294
244
    object_class_foreach(object_class_get_list_tramp,
1295
244
                         implements_type, include_abstract, &list);
1296
244
    return list;
1297
244
}
1298
1299
static gint object_class_cmp(gconstpointer a, gconstpointer b, gpointer d)
1300
66.9k
{
1301
66.9k
    return g_ascii_strcasecmp(object_class_get_name((ObjectClass *)a),
1302
66.9k
                              object_class_get_name((ObjectClass *)b));
1303
66.9k
}
1304
1305
GSList *object_class_get_list_sorted(const char *implements_type,
1306
                                     bool include_abstract)
1307
61
{
1308
61
    return g_slist_sort_with_data(
1309
61
        object_class_get_list(implements_type, include_abstract),
1310
61
        object_class_cmp, NULL);
1311
61
}
1312
1313
Object *object_ref(void *objptr)
1314
467M
{
1315
467M
    Object *obj = OBJECT(objptr);
1316
467M
    uint32_t ref;
1317
1318
467M
    if (!obj) {
1319
0
        return NULL;
1320
0
    }
1321
467M
    ref = qatomic_fetch_inc(&obj->ref);
1322
    /* Assert waaay before the integer overflows */
1323
467M
    g_assert(ref < INT_MAX);
1324
467M
    return obj;
1325
467M
}
1326
1327
void object_unref(void *objptr)
1328
475M
{
1329
475M
    Object *obj = OBJECT(objptr);
1330
475M
    if (!obj) {
1331
8.05M
        return;
1332
8.05M
    }
1333
475M
    g_assert(obj->ref > 0);
1334
1335
    /* parent always holds a reference to its children */
1336
466M
    if (qatomic_fetch_dec(&obj->ref) == 1) {
1337
8.04M
        object_finalize(obj);
1338
8.04M
    }
1339
466M
}
1340
1341
ObjectProperty *
1342
object_property_try_add(Object *obj, const char *name, const char *type,
1343
                        ObjectPropertyAccessor *get,
1344
                        ObjectPropertyAccessor *set,
1345
                        ObjectPropertyRelease *release,
1346
                        void *opaque, Error **errp)
1347
32.4M
{
1348
32.4M
    ObjectProperty *prop;
1349
32.4M
    size_t name_len = strlen(name);
1350
1351
32.4M
    if (name_len >= 3 && !memcmp(name + name_len - 3, "[*]", 4)) {
1352
71.2k
        int i;
1353
71.2k
        ObjectProperty *ret = NULL;
1354
71.2k
        char *name_no_array = g_strdup(name);
1355
1356
71.2k
        name_no_array[name_len - 3] = '\0';
1357
124k
        for (i = 0; i < INT16_MAX; ++i) {
1358
124k
            char *full_name = g_strdup_printf("%s[%d]", name_no_array, i);
1359
1360
124k
            ret = object_property_try_add(obj, full_name, type, get, set,
1361
124k
                                          release, opaque, NULL);
1362
124k
            g_free(full_name);
1363
124k
            if (ret) {
1364
71.2k
                break;
1365
71.2k
            }
1366
124k
        }
1367
71.2k
        g_free(name_no_array);
1368
71.2k
        assert(ret);
1369
71.2k
        return ret;
1370
71.2k
    }
1371
1372
32.3M
    if (object_property_find(obj, name) != NULL) {
1373
52.9k
        error_setg(errp, "attempt to add duplicate property '%s' to object (type '%s')",
1374
52.9k
                   name, object_get_typename(obj));
1375
52.9k
        return NULL;
1376
52.9k
    }
1377
1378
32.3M
    prop = g_malloc0(sizeof(*prop));
1379
1380
32.3M
    prop->name = g_strdup(name);
1381
32.3M
    prop->type = g_strdup(type);
1382
1383
32.3M
    prop->get = get;
1384
32.3M
    prop->set = set;
1385
32.3M
    prop->release = release;
1386
32.3M
    prop->opaque = opaque;
1387
1388
32.3M
    trace_object_property_add(obj, obj->class->type->name,
1389
32.3M
                              prop->name, prop->opaque);
1390
32.3M
    g_hash_table_insert(obj->properties, prop->name, prop);
1391
32.3M
    return prop;
1392
32.3M
}
1393
1394
ObjectProperty *
1395
object_property_add(Object *obj, const char *name, const char *type,
1396
                    ObjectPropertyAccessor *get,
1397
                    ObjectPropertyAccessor *set,
1398
                    ObjectPropertyRelease *release,
1399
                    void *opaque)
1400
32.2M
{
1401
32.2M
    return object_property_try_add(obj, name, type, get, set, release,
1402
32.2M
                                   opaque, &error_abort);
1403
32.2M
}
1404
1405
ObjectProperty *
1406
object_class_property_add(ObjectClass *klass,
1407
                          const char *name,
1408
                          const char *type,
1409
                          ObjectPropertyAccessor *get,
1410
                          ObjectPropertyAccessor *set,
1411
                          ObjectPropertyRelease *release,
1412
                          void *opaque)
1413
127k
{
1414
127k
    bool prop_already_exists = object_class_property_find(klass, name);
1415
127k
    ObjectProperty *prop;
1416
1417
127k
    assert(!prop_already_exists);
1418
1419
127k
    prop = g_malloc0(sizeof(*prop));
1420
1421
127k
    prop->name = g_strdup(name);
1422
127k
    prop->type = g_strdup(type);
1423
1424
127k
    prop->get = get;
1425
127k
    prop->set = set;
1426
127k
    prop->release = release;
1427
127k
    prop->opaque = opaque;
1428
1429
127k
    trace_object_class_property_add(klass->type->name, prop->name,
1430
127k
                                    prop->opaque);
1431
127k
    g_hash_table_insert(klass->properties, prop->name, prop);
1432
1433
127k
    return prop;
1434
127k
}
1435
1436
ObjectProperty *object_property_find(Object *obj, const char *name)
1437
56.2M
{
1438
56.2M
    ObjectProperty *prop;
1439
56.2M
    ObjectClass *klass = object_get_class(obj);
1440
1441
56.2M
    prop = object_class_property_find(klass, name);
1442
56.2M
    if (prop) {
1443
23.7M
        return prop;
1444
23.7M
    }
1445
1446
32.4M
    return g_hash_table_lookup(obj->properties, name);
1447
56.2M
}
1448
1449
ObjectProperty *object_property_find_err(Object *obj, const char *name,
1450
                                         Error **errp)
1451
23.8M
{
1452
23.8M
    ObjectProperty *prop = object_property_find(obj, name);
1453
23.8M
    if (!prop) {
1454
77
        error_setg(errp, "Property '%s.%s' not found",
1455
77
                   object_get_typename(obj), name);
1456
77
    }
1457
23.8M
    return prop;
1458
23.8M
}
1459
1460
void object_property_iter_init(ObjectPropertyIterator *iter,
1461
                               Object *obj)
1462
16.1M
{
1463
16.1M
    g_hash_table_iter_init(&iter->iter, obj->properties);
1464
16.1M
    iter->nextclass = object_get_class(obj);
1465
16.1M
}
1466
1467
ObjectProperty *object_property_iter_next(ObjectPropertyIterator *iter)
1468
97.3M
{
1469
97.3M
    gpointer key, val;
1470
121M
    while (!g_hash_table_iter_next(&iter->iter, &key, &val)) {
1471
40.3M
        if (!iter->nextclass) {
1472
16.1M
            return NULL;
1473
16.1M
        }
1474
24.1M
        g_hash_table_iter_init(&iter->iter, iter->nextclass->properties);
1475
24.1M
        iter->nextclass = object_class_get_parent(iter->nextclass);
1476
24.1M
    }
1477
81.2M
    return val;
1478
97.3M
}
1479
1480
void object_class_property_iter_init(ObjectPropertyIterator *iter,
1481
                                     ObjectClass *klass)
1482
8.07M
{
1483
8.07M
    g_hash_table_iter_init(&iter->iter, klass->properties);
1484
8.07M
    iter->nextclass = object_class_get_parent(klass);
1485
8.07M
}
1486
1487
ObjectProperty *object_class_property_find(ObjectClass *klass, const char *name)
1488
160M
{
1489
160M
    ObjectClass *parent_klass;
1490
1491
160M
    parent_klass = object_class_get_parent(klass);
1492
160M
    if (parent_klass) {
1493
104M
        ObjectProperty *prop =
1494
104M
            object_class_property_find(parent_klass, name);
1495
104M
        if (prop) {
1496
23.0M
            return prop;
1497
23.0M
        }
1498
104M
    }
1499
1500
137M
    return g_hash_table_lookup(klass->properties, name);
1501
160M
}
1502
1503
ObjectProperty *object_class_property_find_err(ObjectClass *klass,
1504
                                               const char *name,
1505
                                               Error **errp)
1506
0
{
1507
0
    ObjectProperty *prop = object_class_property_find(klass, name);
1508
0
    if (!prop) {
1509
0
        error_setg(errp, "Property '.%s' not found", name);
1510
0
    }
1511
0
    return prop;
1512
0
}
1513
1514
1515
void object_property_del(Object *obj, const char *name)
1516
0
{
1517
0
    ObjectProperty *prop = g_hash_table_lookup(obj->properties, name);
1518
1519
0
    trace_object_property_del(obj, obj->class->type->name, prop->name,
1520
0
                              prop->opaque);
1521
0
    if (prop->release) {
1522
0
        prop->release(obj, name, prop->opaque);
1523
0
    }
1524
0
    g_hash_table_remove(obj->properties, name);
1525
0
}
1526
1527
bool object_property_get(Object *obj, const char *name, Visitor *v,
1528
                         Error **errp)
1529
23.7M
{
1530
23.7M
    Error *err = NULL;
1531
23.7M
    ObjectProperty *prop = object_property_find_err(obj, name, errp);
1532
1533
23.7M
    if (prop == NULL) {
1534
77
        return false;
1535
77
    }
1536
1537
23.7M
    if (!prop->get) {
1538
0
        error_setg(errp, "Property '%s.%s' is not readable",
1539
0
                   object_get_typename(obj), name);
1540
0
        return false;
1541
0
    }
1542
23.7M
    prop->get(obj, v, name, prop->opaque, &err);
1543
23.7M
    error_propagate(errp, err);
1544
23.7M
    return !err;
1545
23.7M
}
1546
1547
bool object_property_set(Object *obj, const char *name, Visitor *v,
1548
                         Error **errp)
1549
12.9k
{
1550
12.9k
    ERRP_GUARD();
1551
12.9k
    ObjectProperty *prop = object_property_find_err(obj, name, errp);
1552
1553
12.9k
    if (prop == NULL) {
1554
0
        return false;
1555
0
    }
1556
1557
12.9k
    if (!prop->set) {
1558
0
        error_setg(errp, "Property '%s.%s' is not writable",
1559
0
                   object_get_typename(obj), name);
1560
0
        return false;
1561
0
    }
1562
12.9k
    prop->set(obj, v, name, prop->opaque, errp);
1563
12.9k
    return !*errp;
1564
12.9k
}
1565
1566
bool object_property_set_str(Object *obj, const char *name,
1567
                             const char *value, Error **errp)
1568
4.85k
{
1569
4.85k
    QString *qstr = qstring_from_str(value);
1570
4.85k
    bool ok = object_property_set_qobject(obj, name, QOBJECT(qstr), errp);
1571
1572
4.85k
    qobject_unref(qstr);
1573
4.85k
    return ok;
1574
4.85k
}
1575
1576
char *object_property_get_str(Object *obj, const char *name,
1577
                              Error **errp)
1578
0
{
1579
0
    QObject *ret = object_property_get_qobject(obj, name, errp);
1580
0
    QString *qstring;
1581
0
    char *retval;
1582
1583
0
    if (!ret) {
1584
0
        return NULL;
1585
0
    }
1586
0
    qstring = qobject_to(QString, ret);
1587
0
    if (!qstring) {
1588
0
        error_setg(errp, "Invalid parameter type for '%s', expected: string",
1589
0
                   name);
1590
0
        retval = NULL;
1591
0
    } else {
1592
0
        retval = g_strdup(qstring_get_str(qstring));
1593
0
    }
1594
1595
0
    qobject_unref(ret);
1596
0
    return retval;
1597
0
}
1598
1599
bool object_property_set_link(Object *obj, const char *name,
1600
                              Object *value, Error **errp)
1601
4.38k
{
1602
4.38k
    g_autofree char *path = NULL;
1603
1604
4.38k
    if (value) {
1605
4.38k
        path = object_get_canonical_path(value);
1606
4.38k
    }
1607
4.38k
    return object_property_set_str(obj, name, path ?: "", errp);
1608
4.38k
}
1609
1610
Object *object_property_get_link(Object *obj, const char *name,
1611
                                 Error **errp)
1612
0
{
1613
0
    char *str = object_property_get_str(obj, name, errp);
1614
0
    Object *target = NULL;
1615
1616
0
    if (str && *str) {
1617
0
        target = object_resolve_path(str, NULL);
1618
0
        if (!target) {
1619
0
            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1620
0
                      "Device '%s' not found", str);
1621
0
        }
1622
0
    }
1623
1624
0
    g_free(str);
1625
0
    return target;
1626
0
}
1627
1628
bool object_property_set_bool(Object *obj, const char *name,
1629
                              bool value, Error **errp)
1630
3.37k
{
1631
3.37k
    QBool *qbool = qbool_from_bool(value);
1632
3.37k
    bool ok = object_property_set_qobject(obj, name, QOBJECT(qbool), errp);
1633
1634
3.37k
    qobject_unref(qbool);
1635
3.37k
    return ok;
1636
3.37k
}
1637
1638
bool object_property_get_bool(Object *obj, const char *name,
1639
                              Error **errp)
1640
313
{
1641
313
    QObject *ret = object_property_get_qobject(obj, name, errp);
1642
313
    QBool *qbool;
1643
313
    bool retval;
1644
1645
313
    if (!ret) {
1646
61
        return false;
1647
61
    }
1648
252
    qbool = qobject_to(QBool, ret);
1649
252
    if (!qbool) {
1650
0
        error_setg(errp, "Invalid parameter type for '%s', expected: boolean",
1651
0
                   name);
1652
0
        retval = false;
1653
252
    } else {
1654
252
        retval = qbool_get_bool(qbool);
1655
252
    }
1656
1657
252
    qobject_unref(ret);
1658
252
    return retval;
1659
313
}
1660
1661
bool object_property_set_int(Object *obj, const char *name,
1662
                             int64_t value, Error **errp)
1663
4.22k
{
1664
4.22k
    QNum *qnum = qnum_from_int(value);
1665
4.22k
    bool ok = object_property_set_qobject(obj, name, QOBJECT(qnum), errp);
1666
1667
4.22k
    qobject_unref(qnum);
1668
4.22k
    return ok;
1669
4.22k
}
1670
1671
int64_t object_property_get_int(Object *obj, const char *name,
1672
                                Error **errp)
1673
61
{
1674
61
    QObject *ret = object_property_get_qobject(obj, name, errp);
1675
61
    QNum *qnum;
1676
61
    int64_t retval;
1677
1678
61
    if (!ret) {
1679
0
        return -1;
1680
0
    }
1681
1682
61
    qnum = qobject_to(QNum, ret);
1683
61
    if (!qnum || !qnum_get_try_int(qnum, &retval)) {
1684
0
        error_setg(errp, "Invalid parameter type for '%s', expected: int",
1685
0
                   name);
1686
0
        retval = -1;
1687
0
    }
1688
1689
61
    qobject_unref(ret);
1690
61
    return retval;
1691
61
}
1692
1693
static void object_property_init_defval(Object *obj, ObjectProperty *prop)
1694
48.6k
{
1695
48.6k
    Visitor *v = qobject_input_visitor_new(prop->defval);
1696
1697
48.6k
    assert(prop->set != NULL);
1698
48.6k
    prop->set(obj, v, prop->name, prop->opaque, &error_abort);
1699
1700
48.6k
    visit_free(v);
1701
48.6k
}
1702
1703
static void object_property_set_default(ObjectProperty *prop, QObject *defval)
1704
69.8k
{
1705
69.8k
    assert(!prop->defval);
1706
69.8k
    assert(!prop->init);
1707
1708
69.8k
    prop->defval = defval;
1709
69.8k
    prop->init = object_property_init_defval;
1710
69.8k
}
1711
1712
void object_property_set_default_bool(ObjectProperty *prop, bool value)
1713
23.9k
{
1714
23.9k
    object_property_set_default(prop, QOBJECT(qbool_from_bool(value)));
1715
23.9k
}
1716
1717
void object_property_set_default_str(ObjectProperty *prop, const char *value)
1718
9.57k
{
1719
9.57k
    object_property_set_default(prop, QOBJECT(qstring_from_str(value)));
1720
9.57k
}
1721
1722
void object_property_set_default_list(ObjectProperty *prop)
1723
854
{
1724
854
    object_property_set_default(prop, QOBJECT(qlist_new()));
1725
854
}
1726
1727
void object_property_set_default_int(ObjectProperty *prop, int64_t value)
1728
1.52k
{
1729
1.52k
    object_property_set_default(prop, QOBJECT(qnum_from_int(value)));
1730
1.52k
}
1731
1732
void object_property_set_default_uint(ObjectProperty *prop, uint64_t value)
1733
33.9k
{
1734
33.9k
    object_property_set_default(prop, QOBJECT(qnum_from_uint(value)));
1735
33.9k
}
1736
1737
bool object_property_set_uint(Object *obj, const char *name,
1738
                              uint64_t value, Error **errp)
1739
207
{
1740
207
    QNum *qnum = qnum_from_uint(value);
1741
207
    bool ok = object_property_set_qobject(obj, name, QOBJECT(qnum), errp);
1742
1743
207
    qobject_unref(qnum);
1744
207
    return ok;
1745
207
}
1746
1747
uint64_t object_property_get_uint(Object *obj, const char *name,
1748
                                  Error **errp)
1749
23.7M
{
1750
23.7M
    QObject *ret = object_property_get_qobject(obj, name, errp);
1751
23.7M
    QNum *qnum;
1752
23.7M
    uint64_t retval;
1753
1754
23.7M
    if (!ret) {
1755
0
        return 0;
1756
0
    }
1757
23.7M
    qnum = qobject_to(QNum, ret);
1758
23.7M
    if (!qnum || !qnum_get_try_uint(qnum, &retval)) {
1759
0
        error_setg(errp, "Invalid parameter type for '%s', expected: uint",
1760
0
                   name);
1761
0
        retval = 0;
1762
0
    }
1763
1764
23.7M
    qobject_unref(ret);
1765
23.7M
    return retval;
1766
23.7M
}
1767
1768
typedef struct EnumProperty {
1769
    const QEnumLookup *lookup;
1770
    int (*get)(Object *, Error **);
1771
    void (*set)(Object *, int, Error **);
1772
} EnumProperty;
1773
1774
int object_property_get_enum(Object *obj, const char *name,
1775
                             const char *typename, Error **errp)
1776
0
{
1777
0
    char *str;
1778
0
    int ret;
1779
0
    ObjectProperty *prop = object_property_find_err(obj, name, errp);
1780
0
    EnumProperty *enumprop;
1781
1782
0
    if (prop == NULL) {
1783
0
        return -1;
1784
0
    }
1785
1786
0
    if (!g_str_equal(prop->type, typename)) {
1787
0
        error_setg(errp, "Property %s on %s is not '%s' enum type",
1788
0
                   name, object_class_get_name(
1789
0
                       object_get_class(obj)), typename);
1790
0
        return -1;
1791
0
    }
1792
1793
0
    enumprop = prop->opaque;
1794
1795
0
    str = object_property_get_str(obj, name, errp);
1796
0
    if (!str) {
1797
0
        return -1;
1798
0
    }
1799
1800
0
    ret = qapi_enum_parse(enumprop->lookup, str, -1, errp);
1801
0
    g_free(str);
1802
1803
0
    return ret;
1804
0
}
1805
1806
bool object_property_parse(Object *obj, const char *name,
1807
                           const char *string, Error **errp)
1808
10
{
1809
10
    Visitor *v;
1810
10
    bool ok;
1811
10
    trace_object_property_parse(obj, obj->class->type->name, name, string);
1812
10
    v = string_input_visitor_new(string);
1813
10
    ok = object_property_set(obj, name, v, errp);
1814
1815
10
    visit_free(v);
1816
10
    return ok;
1817
10
}
1818
1819
char *object_property_print(Object *obj, const char *name, bool human,
1820
                            Error **errp)
1821
0
{
1822
0
    Visitor *v;
1823
0
    char *string = NULL;
1824
1825
0
    v = string_output_visitor_new(human, &string);
1826
0
    if (!object_property_get(obj, name, v, errp)) {
1827
0
        goto out;
1828
0
    }
1829
1830
0
    visit_complete(v, &string);
1831
1832
0
out:
1833
0
    visit_free(v);
1834
0
    return string;
1835
0
}
1836
1837
const char *object_property_get_type(Object *obj, const char *name, Error **errp)
1838
4.38k
{
1839
4.38k
    ObjectProperty *prop = object_property_find_err(obj, name, errp);
1840
4.38k
    if (prop == NULL) {
1841
0
        return NULL;
1842
0
    }
1843
1844
4.38k
    return prop->type;
1845
4.38k
}
1846
1847
static const char *const root_containers[] = {
1848
    "audiodevs",
1849
    "chardevs",
1850
    "objects",
1851
    "backend"
1852
};
1853
1854
static Object *object_root_initialize(void)
1855
61
{
1856
61
    Object *root = object_new(TYPE_CONTAINER);
1857
61
    int i;
1858
1859
    /*
1860
     * Create all QEMU system containers.  "machine" and its sub-containers
1861
     * are only created when machine initializes (qemu_create_machine()).
1862
     */
1863
305
    for (i = 0; i < ARRAY_SIZE(root_containers); i++) {
1864
244
        object_property_add_new_container(root, root_containers[i]);
1865
244
    }
1866
1867
61
    return root;
1868
61
}
1869
1870
Object *object_get_container(const char *name)
1871
401
{
1872
401
    Object *container;
1873
1874
401
    container = object_resolve_path_component(object_get_root(), name);
1875
401
    assert(object_dynamic_cast(container, TYPE_CONTAINER));
1876
1877
401
    return container;
1878
401
}
1879
1880
Object *object_get_root(void)
1881
13.3k
{
1882
13.3k
    static Object *root;
1883
1884
13.3k
    if (!root) {
1885
61
        root = object_root_initialize();
1886
61
    }
1887
1888
13.3k
    return root;
1889
13.3k
}
1890
1891
Object *object_get_objects_root(void)
1892
127
{
1893
127
    return object_get_container("objects");
1894
127
}
1895
1896
Object *object_get_internal_root(void)
1897
0
{
1898
0
    static Object *internal_root;
1899
1900
0
    if (!internal_root) {
1901
0
        internal_root = object_new(TYPE_CONTAINER);
1902
0
    }
1903
1904
0
    return internal_root;
1905
0
}
1906
1907
static void object_get_child_property(Object *obj, Visitor *v,
1908
                                      const char *name, void *opaque,
1909
                                      Error **errp)
1910
0
{
1911
0
    Object *child = opaque;
1912
0
    char *path;
1913
1914
0
    path = object_get_canonical_path(child);
1915
0
    visit_type_str(v, name, &path, errp);
1916
0
    g_free(path);
1917
0
}
1918
1919
static Object *object_resolve_child_property(Object *parent, void *opaque,
1920
                                             const char *part)
1921
19.4k
{
1922
19.4k
    return opaque;
1923
19.4k
}
1924
1925
static void object_finalize_child_property(Object *obj, const char *name,
1926
                                           void *opaque)
1927
61.2k
{
1928
61.2k
    Object *child = opaque;
1929
1930
61.2k
    if (child->class->unparent) {
1931
305
        (child->class->unparent)(child);
1932
305
    }
1933
61.2k
    child->parent = NULL;
1934
61.2k
    object_unref(child);
1935
61.2k
}
1936
1937
ObjectProperty *
1938
object_property_try_add_child(Object *obj, const char *name,
1939
                              Object *child, Error **errp)
1940
78.7k
{
1941
78.7k
    g_autofree char *type = NULL;
1942
78.7k
    ObjectProperty *op;
1943
1944
78.7k
    trace_object_property_add_child(obj, obj->class->type->name, name,
1945
78.7k
                                    child, child->class->type->name);
1946
78.7k
    assert(!child->parent);
1947
1948
78.7k
    type = g_strdup_printf("child<%s>", object_get_typename(child));
1949
1950
78.7k
    op = object_property_try_add(obj, name, type, object_get_child_property,
1951
78.7k
                                 NULL, object_finalize_child_property,
1952
78.7k
                                 child, errp);
1953
78.7k
    if (!op) {
1954
0
        return NULL;
1955
0
    }
1956
78.7k
    op->resolve = object_resolve_child_property;
1957
78.7k
    object_ref(child);
1958
78.7k
    child->parent = obj;
1959
78.7k
    return op;
1960
78.7k
}
1961
1962
ObjectProperty *
1963
object_property_add_child(Object *obj, const char *name,
1964
                          Object *child)
1965
78.6k
{
1966
78.6k
    return object_property_try_add_child(obj, name, child, &error_abort);
1967
78.6k
}
1968
1969
void object_property_allow_set_link(const Object *obj, const char *name,
1970
                                    Object *val, Error **errp)
1971
3.95k
{
1972
    /* Allow the link to be set, always */
1973
3.95k
}
1974
1975
typedef struct {
1976
    union {
1977
        Object **targetp;
1978
        Object *target; /* if OBJ_PROP_LINK_DIRECT, when holding the pointer  */
1979
        ptrdiff_t offset; /* if OBJ_PROP_LINK_CLASS */
1980
    };
1981
    void (*check)(const Object *, const char *, Object *, Error **);
1982
    ObjectPropertyLinkFlags flags;
1983
} LinkProperty;
1984
1985
static Object **
1986
object_link_get_targetp(Object *obj, LinkProperty *lprop)
1987
8.04M
{
1988
8.04M
    if (lprop->flags & OBJ_PROP_LINK_DIRECT) {
1989
0
        return &lprop->target;
1990
8.04M
    } else if (lprop->flags & OBJ_PROP_LINK_CLASS) {
1991
2.21k
        return (void *)obj + lprop->offset;
1992
8.04M
    } else {
1993
8.04M
        return lprop->targetp;
1994
8.04M
    }
1995
8.04M
}
1996
1997
static void object_get_link_property(Object *obj, Visitor *v,
1998
                                     const char *name, void *opaque,
1999
                                     Error **errp)
2000
0
{
2001
0
    LinkProperty *lprop = opaque;
2002
0
    Object **targetp = object_link_get_targetp(obj, lprop);
2003
0
    char *path;
2004
2005
0
    if (*targetp) {
2006
0
        path = object_get_canonical_path(*targetp);
2007
0
        visit_type_str(v, name, &path, errp);
2008
0
        g_free(path);
2009
0
    } else {
2010
0
        path = (char *)"";
2011
0
        visit_type_str(v, name, &path, errp);
2012
0
    }
2013
0
}
2014
2015
Object *object_resolve_and_typecheck(const char *path, const char *name,
2016
                                     const char *target_type, Error **errp)
2017
4.38k
{
2018
4.38k
    bool ambiguous = false;
2019
4.38k
    Object *target;
2020
2021
4.38k
    target = object_resolve_path_type(path, target_type, &ambiguous);
2022
2023
4.38k
    if (ambiguous) {
2024
0
        error_setg(errp, "Path '%s' does not uniquely identify an object",
2025
0
                   path);
2026
4.38k
    } else if (!target) {
2027
0
        target = object_resolve_path(path, &ambiguous);
2028
0
        if (target || ambiguous) {
2029
0
            error_setg(errp, "Invalid parameter type for '%s', expected: %s",
2030
0
                             name, target_type);
2031
0
        } else {
2032
0
            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
2033
0
                      "Device '%s' not found", path);
2034
0
        }
2035
0
        target = NULL;
2036
0
    }
2037
4.38k
    return target;
2038
4.38k
}
2039
2040
/*
2041
 * object_resolve_link:
2042
 *
2043
 * Lookup an object and ensure its type matches the link property type.  This
2044
 * is similar to object_resolve_path() except type verification against the
2045
 * link property is performed.
2046
 *
2047
 * Returns: The matched object or NULL on path lookup failures.
2048
 */
2049
static Object *object_resolve_link(Object *obj, const char *name,
2050
                                   const char *path, Error **errp)
2051
4.38k
{
2052
4.38k
    const char *type;
2053
4.38k
    g_autofree char *target_type = NULL;
2054
2055
    /* Go from link<FOO> to FOO.  */
2056
4.38k
    type = object_property_get_type(obj, name, NULL);
2057
4.38k
    target_type = g_strndup(&type[5], strlen(type) - 6);
2058
4.38k
    return object_resolve_and_typecheck(path, name, target_type, errp);
2059
4.38k
}
2060
2061
static void object_set_link_property(Object *obj, Visitor *v,
2062
                                     const char *name, void *opaque,
2063
                                     Error **errp)
2064
4.38k
{
2065
4.38k
    Error *local_err = NULL;
2066
4.38k
    LinkProperty *prop = opaque;
2067
4.38k
    Object **targetp = object_link_get_targetp(obj, prop);
2068
4.38k
    Object *old_target = *targetp;
2069
4.38k
    Object *new_target;
2070
4.38k
    char *path = NULL;
2071
2072
4.38k
    if (!visit_type_str(v, name, &path, errp)) {
2073
0
        return;
2074
0
    }
2075
2076
4.38k
    if (*path) {
2077
4.38k
        new_target = object_resolve_link(obj, name, path, errp);
2078
4.38k
        if (!new_target) {
2079
0
            g_free(path);
2080
0
            return;
2081
0
        }
2082
4.38k
    } else {
2083
0
        new_target = NULL;
2084
0
    }
2085
2086
4.38k
    g_free(path);
2087
2088
4.38k
    prop->check(obj, name, new_target, &local_err);
2089
4.38k
    if (local_err) {
2090
0
        error_propagate(errp, local_err);
2091
0
        return;
2092
0
    }
2093
2094
4.38k
    *targetp = new_target;
2095
4.38k
    if (prop->flags & OBJ_PROP_LINK_STRONG) {
2096
4.05k
        object_ref(new_target);
2097
4.05k
        object_unref(old_target);
2098
4.05k
    }
2099
4.38k
}
2100
2101
static Object *object_resolve_link_property(Object *parent, void *opaque,
2102
                                            const char *part)
2103
0
{
2104
0
    LinkProperty *lprop = opaque;
2105
2106
0
    return *object_link_get_targetp(parent, lprop);
2107
0
}
2108
2109
static void object_release_link_property(Object *obj, const char *name,
2110
                                         void *opaque)
2111
8.04M
{
2112
8.04M
    LinkProperty *prop = opaque;
2113
8.04M
    Object **targetp = object_link_get_targetp(obj, prop);
2114
2115
8.04M
    if ((prop->flags & OBJ_PROP_LINK_STRONG) && *targetp) {
2116
0
        object_unref(*targetp);
2117
0
    }
2118
8.04M
    if (!(prop->flags & OBJ_PROP_LINK_CLASS)) {
2119
8.04M
        g_free(prop);
2120
8.04M
    }
2121
8.04M
}
2122
2123
static ObjectProperty *
2124
object_add_link_prop(Object *obj, const char *name,
2125
                     const char *type, void *ptr,
2126
                     void (*check)(const Object *, const char *,
2127
                                   Object *, Error **),
2128
                     ObjectPropertyLinkFlags flags)
2129
8.06M
{
2130
8.06M
    LinkProperty *prop = g_malloc(sizeof(*prop));
2131
8.06M
    g_autofree char *full_type = NULL;
2132
8.06M
    ObjectProperty *op;
2133
2134
8.06M
    if (flags & OBJ_PROP_LINK_DIRECT) {
2135
61
        prop->target = ptr;
2136
8.06M
    } else {
2137
8.06M
        prop->targetp = ptr;
2138
8.06M
    }
2139
8.06M
    prop->check = check;
2140
8.06M
    prop->flags = flags;
2141
2142
8.06M
    full_type = g_strdup_printf("link<%s>", type);
2143
2144
8.06M
    op = object_property_add(obj, name, full_type,
2145
8.06M
                             object_get_link_property,
2146
8.06M
                             check ? object_set_link_property : NULL,
2147
8.06M
                             object_release_link_property,
2148
8.06M
                             prop);
2149
8.06M
    op->resolve = object_resolve_link_property;
2150
8.06M
    return op;
2151
8.06M
}
2152
2153
ObjectProperty *
2154
object_property_add_link(Object *obj, const char *name,
2155
                         const char *type, Object **targetp,
2156
                         void (*check)(const Object *, const char *,
2157
                                       Object *, Error **),
2158
                         ObjectPropertyLinkFlags flags)
2159
8.06M
{
2160
8.06M
    return object_add_link_prop(obj, name, type, targetp, check, flags);
2161
8.06M
}
2162
2163
ObjectProperty *
2164
object_class_property_add_link(ObjectClass *oc,
2165
    const char *name,
2166
    const char *type, ptrdiff_t offset,
2167
    void (*check)(const Object *obj, const char *name,
2168
                  Object *val, Error **errp),
2169
    ObjectPropertyLinkFlags flags)
2170
2.50k
{
2171
2.50k
    LinkProperty *prop = g_new0(LinkProperty, 1);
2172
2.50k
    char *full_type;
2173
2.50k
    ObjectProperty *op;
2174
2175
2.50k
    prop->offset = offset;
2176
2.50k
    prop->check = check;
2177
2.50k
    prop->flags = flags | OBJ_PROP_LINK_CLASS;
2178
2179
2.50k
    full_type = g_strdup_printf("link<%s>", type);
2180
2181
2.50k
    op = object_class_property_add(oc, name, full_type,
2182
2.50k
                                   object_get_link_property,
2183
2.50k
                                   check ? object_set_link_property : NULL,
2184
2.50k
                                   object_release_link_property,
2185
2.50k
                                   prop);
2186
2187
2.50k
    op->resolve = object_resolve_link_property;
2188
2189
2.50k
    g_free(full_type);
2190
2.50k
    return op;
2191
2.50k
}
2192
2193
ObjectProperty *
2194
object_property_add_const_link(Object *obj, const char *name,
2195
                               Object *target)
2196
61
{
2197
61
    return object_add_link_prop(obj, name,
2198
61
                                object_get_typename(target), target,
2199
61
                                NULL, OBJ_PROP_LINK_DIRECT);
2200
61
}
2201
2202
const char *object_get_canonical_path_component(const Object *obj)
2203
25.6k
{
2204
25.6k
    ObjectProperty *prop = NULL;
2205
25.6k
    GHashTableIter iter;
2206
2207
25.6k
    if (obj->parent == NULL) {
2208
0
        return NULL;
2209
0
    }
2210
2211
25.6k
    g_hash_table_iter_init(&iter, obj->parent->properties);
2212
300k
    while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
2213
300k
        if (!object_property_is_child(prop)) {
2214
58.5k
            continue;
2215
58.5k
        }
2216
2217
241k
        if (prop->opaque == obj) {
2218
25.6k
            return prop->name;
2219
25.6k
        }
2220
241k
    }
2221
2222
    /* obj had a parent but was not a child, should never happen */
2223
25.6k
    g_assert_not_reached();
2224
0
}
2225
2226
char *object_get_canonical_path(const Object *obj)
2227
6.61k
{
2228
6.61k
    Object *root = object_get_root();
2229
6.61k
    char *newpath, *path = NULL;
2230
2231
6.61k
    if (obj == root) {
2232
0
        return g_strdup("/");
2233
0
    }
2234
2235
20.7k
    do {
2236
20.7k
        const char *component = object_get_canonical_path_component(obj);
2237
2238
20.7k
        if (!component) {
2239
            /* A canonical path must be complete, so discard what was
2240
             * collected so far.
2241
             */
2242
0
            g_free(path);
2243
0
            return NULL;
2244
0
        }
2245
2246
20.7k
        newpath = g_strdup_printf("/%s%s", component, path ? path : "");
2247
20.7k
        g_free(path);
2248
20.7k
        path = newpath;
2249
20.7k
        obj = obj->parent;
2250
20.7k
    } while (obj != root);
2251
2252
6.61k
    return path;
2253
6.61k
}
2254
2255
Object *object_resolve_path_component(Object *parent, const char *part)
2256
19.6k
{
2257
19.6k
    ObjectProperty *prop = object_property_find(parent, part);
2258
19.6k
    if (prop == NULL) {
2259
265
        return NULL;
2260
265
    }
2261
2262
19.4k
    if (prop->resolve) {
2263
19.4k
        return prop->resolve(parent, prop->opaque, part);
2264
19.4k
    } else {
2265
0
        return NULL;
2266
0
    }
2267
19.4k
}
2268
2269
static Object *object_resolve_abs_path(Object *parent,
2270
                                          char **parts,
2271
                                          const char *typename)
2272
323k
{
2273
323k
    Object *child;
2274
2275
323k
    if (*parts == NULL) {
2276
309k
        return object_dynamic_cast(parent, typename);
2277
309k
    }
2278
2279
14.7k
    if (strcmp(*parts, "") == 0) {
2280
0
        return object_resolve_abs_path(parent, parts + 1, typename);
2281
0
    }
2282
2283
14.7k
    child = object_resolve_path_component(parent, *parts);
2284
14.7k
    if (!child) {
2285
265
        return NULL;
2286
265
    }
2287
2288
14.5k
    return object_resolve_abs_path(child, parts + 1, typename);
2289
14.7k
}
2290
2291
static Object *object_resolve_partial_path(Object *parent,
2292
                                           char **parts,
2293
                                           const char *typename,
2294
                                           bool *ambiguous)
2295
304k
{
2296
304k
    Object *obj;
2297
304k
    GHashTableIter iter;
2298
304k
    ObjectProperty *prop;
2299
2300
304k
    obj = object_resolve_abs_path(parent, parts, typename);
2301
2302
304k
    g_hash_table_iter_init(&iter, parent->properties);
2303
1.38M
    while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
2304
1.07M
        Object *found;
2305
2306
1.07M
        if (!object_property_is_child(prop)) {
2307
776k
            continue;
2308
776k
        }
2309
2310
303k
        found = object_resolve_partial_path(prop->opaque, parts,
2311
303k
                                            typename, ambiguous);
2312
303k
        if (found) {
2313
1.33k
            if (obj) {
2314
0
                *ambiguous = true;
2315
0
                return NULL;
2316
0
            }
2317
1.33k
            obj = found;
2318
1.33k
        }
2319
2320
303k
        if (*ambiguous) {
2321
0
            return NULL;
2322
0
        }
2323
303k
    }
2324
2325
304k
    return obj;
2326
304k
}
2327
2328
Object *object_resolve_path_type(const char *path, const char *typename,
2329
                                 bool *ambiguous)
2330
6.17k
{
2331
6.17k
    Object *obj;
2332
6.17k
    char **parts;
2333
2334
6.17k
    parts = g_strsplit(path, "/", 0);
2335
6.17k
    assert(parts);
2336
2337
6.17k
    if (parts[0] == NULL || strcmp(parts[0], "") != 0) {
2338
1.21k
        bool ambig = false;
2339
1.21k
        obj = object_resolve_partial_path(object_get_root(), parts,
2340
1.21k
                                          typename, &ambig);
2341
1.21k
        if (ambiguous) {
2342
305
            *ambiguous = ambig;
2343
305
        }
2344
4.95k
    } else {
2345
4.95k
        obj = object_resolve_abs_path(object_get_root(), parts + 1, typename);
2346
4.95k
        if (ambiguous) {
2347
4.38k
            *ambiguous = false;
2348
4.38k
        }
2349
4.95k
    }
2350
2351
6.17k
    g_strfreev(parts);
2352
2353
6.17k
    return obj;
2354
6.17k
}
2355
2356
Object *object_resolve_path(const char *path, bool *ambiguous)
2357
570
{
2358
570
    return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
2359
570
}
2360
2361
Object *object_resolve_path_at(Object *parent, const char *path)
2362
0
{
2363
0
    g_auto(GStrv) parts = g_strsplit(path, "/", 0);
2364
2365
0
    if (*path == '/') {
2366
0
        return object_resolve_abs_path(object_get_root(), parts + 1,
2367
0
                                       TYPE_OBJECT);
2368
0
    }
2369
0
    return object_resolve_abs_path(parent, parts, TYPE_OBJECT);
2370
0
}
2371
2372
Object *object_resolve_type_unambiguous(const char *typename, Error **errp)
2373
244
{
2374
244
    bool ambig = false;
2375
244
    Object *o = object_resolve_path_type("", typename, &ambig);
2376
2377
244
    if (ambig) {
2378
0
        error_setg(errp, "More than one object of type %s", typename);
2379
0
        return NULL;
2380
0
    }
2381
244
    if (!o) {
2382
122
        error_setg(errp, "No object found of type %s", typename);
2383
122
        return NULL;
2384
122
    }
2385
122
    return o;
2386
244
}
2387
2388
typedef struct StringProperty
2389
{
2390
    char *(*get)(Object *, Error **);
2391
    void (*set)(Object *, const char *, Error **);
2392
} StringProperty;
2393
2394
static void property_get_str(Object *obj, Visitor *v, const char *name,
2395
                             void *opaque, Error **errp)
2396
0
{
2397
0
    StringProperty *prop = opaque;
2398
0
    char *value;
2399
0
    Error *err = NULL;
2400
2401
0
    value = prop->get(obj, &err);
2402
0
    if (err) {
2403
0
        error_propagate(errp, err);
2404
0
        return;
2405
0
    }
2406
2407
0
    visit_type_str(v, name, &value, errp);
2408
0
    g_free(value);
2409
0
}
2410
2411
static void property_set_str(Object *obj, Visitor *v, const char *name,
2412
                             void *opaque, Error **errp)
2413
310
{
2414
310
    StringProperty *prop = opaque;
2415
310
    char *value;
2416
2417
310
    if (!visit_type_str(v, name, &value, errp)) {
2418
0
        return;
2419
0
    }
2420
2421
310
    prop->set(obj, value, errp);
2422
310
    g_free(value);
2423
310
}
2424
2425
static void property_release_data(Object *obj, const char *name,
2426
                                  void *opaque)
2427
0
{
2428
0
    g_free(opaque);
2429
0
}
2430
2431
ObjectProperty *
2432
object_property_add_str(Object *obj, const char *name,
2433
                        char *(*get)(Object *, Error **),
2434
                        void (*set)(Object *, const char *, Error **))
2435
61
{
2436
61
    StringProperty *prop = g_malloc0(sizeof(*prop));
2437
2438
61
    prop->get = get;
2439
61
    prop->set = set;
2440
2441
61
    return object_property_add(obj, name, "string",
2442
61
                               get ? property_get_str : NULL,
2443
61
                               set ? property_set_str : NULL,
2444
61
                               property_release_data,
2445
61
                               prop);
2446
61
}
2447
2448
ObjectProperty *
2449
object_class_property_add_str(ObjectClass *klass, const char *name,
2450
                                   char *(*get)(Object *, Error **),
2451
                                   void (*set)(Object *, const char *,
2452
                                               Error **))
2453
3.84k
{
2454
3.84k
    StringProperty *prop = g_malloc0(sizeof(*prop));
2455
2456
3.84k
    prop->get = get;
2457
3.84k
    prop->set = set;
2458
2459
3.84k
    return object_class_property_add(klass, name, "string",
2460
3.84k
                                     get ? property_get_str : NULL,
2461
3.84k
                                     set ? property_set_str : NULL,
2462
3.84k
                                     NULL,
2463
3.84k
                                     prop);
2464
3.84k
}
2465
2466
typedef struct BoolProperty
2467
{
2468
    bool (*get)(Object *, Error **);
2469
    void (*set)(Object *, bool, Error **);
2470
} BoolProperty;
2471
2472
static void property_get_bool(Object *obj, Visitor *v, const char *name,
2473
                              void *opaque, Error **errp)
2474
0
{
2475
0
    BoolProperty *prop = opaque;
2476
0
    bool value;
2477
0
    Error *err = NULL;
2478
2479
0
    value = prop->get(obj, &err);
2480
0
    if (err) {
2481
0
        error_propagate(errp, err);
2482
0
        return;
2483
0
    }
2484
2485
0
    visit_type_bool(v, name, &value, errp);
2486
0
}
2487
2488
static void property_set_bool(Object *obj, Visitor *v, const char *name,
2489
                              void *opaque, Error **errp)
2490
2.86k
{
2491
2.86k
    BoolProperty *prop = opaque;
2492
2.86k
    bool value;
2493
2494
2.86k
    if (!visit_type_bool(v, name, &value, errp)) {
2495
0
        return;
2496
0
    }
2497
2498
2.86k
    prop->set(obj, value, errp);
2499
2.86k
}
2500
2501
ObjectProperty *
2502
object_property_add_bool(Object *obj, const char *name,
2503
                         bool (*get)(Object *, Error **),
2504
                         void (*set)(Object *, bool, Error **))
2505
849
{
2506
849
    BoolProperty *prop = g_malloc0(sizeof(*prop));
2507
2508
849
    prop->get = get;
2509
849
    prop->set = set;
2510
2511
849
    return object_property_add(obj, name, "bool",
2512
849
                               get ? property_get_bool : NULL,
2513
849
                               set ? property_set_bool : NULL,
2514
849
                               property_release_data,
2515
849
                               prop);
2516
849
}
2517
2518
ObjectProperty *
2519
object_class_property_add_bool(ObjectClass *klass, const char *name,
2520
                                    bool (*get)(Object *, Error **),
2521
                                    void (*set)(Object *, bool, Error **))
2522
4.20k
{
2523
4.20k
    BoolProperty *prop = g_malloc0(sizeof(*prop));
2524
2525
4.20k
    prop->get = get;
2526
4.20k
    prop->set = set;
2527
2528
4.20k
    return object_class_property_add(klass, name, "bool",
2529
4.20k
                                     get ? property_get_bool : NULL,
2530
4.20k
                                     set ? property_set_bool : NULL,
2531
4.20k
                                     NULL,
2532
4.20k
                                     prop);
2533
4.20k
}
2534
2535
static void property_get_enum(Object *obj, Visitor *v, const char *name,
2536
                              void *opaque, Error **errp)
2537
0
{
2538
0
    EnumProperty *prop = opaque;
2539
0
    int value;
2540
0
    Error *err = NULL;
2541
2542
0
    value = prop->get(obj, &err);
2543
0
    if (err) {
2544
0
        error_propagate(errp, err);
2545
0
        return;
2546
0
    }
2547
2548
0
    visit_type_enum(v, name, &value, prop->lookup, errp);
2549
0
}
2550
2551
static void property_set_enum(Object *obj, Visitor *v, const char *name,
2552
                              void *opaque, Error **errp)
2553
0
{
2554
0
    EnumProperty *prop = opaque;
2555
0
    int value;
2556
2557
0
    if (!visit_type_enum(v, name, &value, prop->lookup, errp)) {
2558
0
        return;
2559
0
    }
2560
0
    prop->set(obj, value, errp);
2561
0
}
2562
2563
ObjectProperty *
2564
object_property_add_enum(Object *obj, const char *name,
2565
                         const char *typename,
2566
                         const QEnumLookup *lookup,
2567
                         int (*get)(Object *, Error **),
2568
                         void (*set)(Object *, int, Error **))
2569
0
{
2570
0
    EnumProperty *prop = g_malloc(sizeof(*prop));
2571
2572
0
    prop->lookup = lookup;
2573
0
    prop->get = get;
2574
0
    prop->set = set;
2575
2576
0
    return object_property_add(obj, name, typename,
2577
0
                               get ? property_get_enum : NULL,
2578
0
                               set ? property_set_enum : NULL,
2579
0
                               property_release_data,
2580
0
                               prop);
2581
0
}
2582
2583
ObjectProperty *
2584
object_class_property_add_enum(ObjectClass *klass, const char *name,
2585
                                    const char *typename,
2586
                                    const QEnumLookup *lookup,
2587
                                    int (*get)(Object *, Error **),
2588
                                    void (*set)(Object *, int, Error **))
2589
1.76k
{
2590
1.76k
    EnumProperty *prop = g_malloc(sizeof(*prop));
2591
2592
1.76k
    prop->lookup = lookup;
2593
1.76k
    prop->get = get;
2594
1.76k
    prop->set = set;
2595
2596
1.76k
    return object_class_property_add(klass, name, typename,
2597
1.76k
                                     get ? property_get_enum : NULL,
2598
1.76k
                                     set ? property_set_enum : NULL,
2599
1.76k
                                     NULL,
2600
1.76k
                                     prop);
2601
1.76k
}
2602
2603
typedef struct TMProperty {
2604
    void (*get)(Object *, struct tm *, Error **);
2605
} TMProperty;
2606
2607
static void property_get_tm(Object *obj, Visitor *v, const char *name,
2608
                            void *opaque, Error **errp)
2609
0
{
2610
0
    TMProperty *prop = opaque;
2611
0
    Error *err = NULL;
2612
0
    struct tm value;
2613
2614
0
    prop->get(obj, &value, &err);
2615
0
    if (err) {
2616
0
        error_propagate(errp, err);
2617
0
        return;
2618
0
    }
2619
2620
0
    if (!visit_start_struct(v, name, NULL, 0, errp)) {
2621
0
        return;
2622
0
    }
2623
0
    if (!visit_type_int32(v, "tm_year", &value.tm_year, errp)) {
2624
0
        goto out_end;
2625
0
    }
2626
0
    if (!visit_type_int32(v, "tm_mon", &value.tm_mon, errp)) {
2627
0
        goto out_end;
2628
0
    }
2629
0
    if (!visit_type_int32(v, "tm_mday", &value.tm_mday, errp)) {
2630
0
        goto out_end;
2631
0
    }
2632
0
    if (!visit_type_int32(v, "tm_hour", &value.tm_hour, errp)) {
2633
0
        goto out_end;
2634
0
    }
2635
0
    if (!visit_type_int32(v, "tm_min", &value.tm_min, errp)) {
2636
0
        goto out_end;
2637
0
    }
2638
0
    if (!visit_type_int32(v, "tm_sec", &value.tm_sec, errp)) {
2639
0
        goto out_end;
2640
0
    }
2641
0
    visit_check_struct(v, errp);
2642
0
out_end:
2643
0
    visit_end_struct(v, NULL);
2644
0
}
2645
2646
ObjectProperty *
2647
object_property_add_tm(Object *obj, const char *name,
2648
                       void (*get)(Object *, struct tm *, Error **))
2649
0
{
2650
0
    TMProperty *prop = g_malloc0(sizeof(*prop));
2651
2652
0
    prop->get = get;
2653
2654
0
    return object_property_add(obj, name, "struct tm",
2655
0
                               get ? property_get_tm : NULL, NULL,
2656
0
                               property_release_data,
2657
0
                               prop);
2658
0
}
2659
2660
ObjectProperty *
2661
object_class_property_add_tm(ObjectClass *klass, const char *name,
2662
                             void (*get)(Object *, struct tm *, Error **))
2663
61
{
2664
61
    TMProperty *prop = g_malloc0(sizeof(*prop));
2665
2666
61
    prop->get = get;
2667
2668
61
    return object_class_property_add(klass, name, "struct tm",
2669
61
                                     get ? property_get_tm : NULL,
2670
61
                                     NULL, NULL, prop);
2671
61
}
2672
2673
static char *object_get_type(Object *obj, Error **errp)
2674
0
{
2675
0
    return g_strdup(object_get_typename(obj));
2676
0
}
2677
2678
2679
#define OBJECT_PROPERTY_SCALAR_GETTER(type) \
2680
    static void property_get_##type##_ptr(Object *obj, Visitor *v, \
2681
                                          const char *name, \
2682
                                          void *opaque, Error **errp) \
2683
199
    { \
2684
199
        type##_t value = *(type##_t *)opaque; \
2685
199
        visit_type_##type(v, name, &value, errp); \
2686
199
    }
object.c:property_get_uint8_ptr
Line
Count
Source
2683
122
    { \
2684
122
        type##_t value = *(type##_t *)opaque; \
2685
122
        visit_type_##type(v, name, &value, errp); \
2686
122
    }
object.c:property_get_uint16_ptr
Line
Count
Source
2683
8
    { \
2684
8
        type##_t value = *(type##_t *)opaque; \
2685
8
        visit_type_##type(v, name, &value, errp); \
2686
8
    }
object.c:property_get_uint32_ptr
Line
Count
Source
2683
69
    { \
2684
69
        type##_t value = *(type##_t *)opaque; \
2685
69
        visit_type_##type(v, name, &value, errp); \
2686
69
    }
Unexecuted instantiation: object.c:property_get_uint64_ptr
2687
2688
2689
#define OBJECT_PROPERTY_SCALAR_SETTER(type) \
2690
    static void property_set_##type##_ptr(Object *obj, Visitor *v, \
2691
                                          const char *name, \
2692
                                          void *opaque, Error **errp) \
2693
0
    { \
2694
0
        type##_t *field = opaque; \
2695
0
        type##_t value; \
2696
0
        \
2697
0
        if (!visit_type_##type(v, name, &value, errp)) { \
2698
0
            return; \
2699
0
        } \
2700
0
        \
2701
0
        *field = value; \
2702
0
    }
Unexecuted instantiation: object.c:property_set_uint8_ptr
Unexecuted instantiation: object.c:property_set_uint16_ptr
Unexecuted instantiation: object.c:property_set_uint32_ptr
Unexecuted instantiation: object.c:property_set_uint64_ptr
2703
2704
2705
#define DEFINE_OBJECT_PROPERTY_SCALAR_METHODS(type) \
2706
    OBJECT_PROPERTY_SCALAR_GETTER(type) \
2707
    OBJECT_PROPERTY_SCALAR_SETTER(type)
2708
2709
2710
DEFINE_OBJECT_PROPERTY_SCALAR_METHODS(uint8)
2711
DEFINE_OBJECT_PROPERTY_SCALAR_METHODS(uint16)
2712
DEFINE_OBJECT_PROPERTY_SCALAR_METHODS(uint32)
2713
DEFINE_OBJECT_PROPERTY_SCALAR_METHODS(uint64)
2714
2715
#undef OBJECT_PROPERTY_SCALAR_GETTER
2716
#undef OBJECT_PROPERTY_SCALAR_SETTER
2717
#undef DEFINE_OBJECT_PROPERTY_SCALAR_METHODS
2718
2719
2720
static void *object_class_prop_ptr(Object *obj, ptrdiff_t offset)
2721
23.7M
{
2722
23.7M
    void *ptr = obj;
2723
23.7M
    ptr += offset;
2724
2725
23.7M
    return ptr;
2726
23.7M
}
2727
2728
#define OBJECT_CLASS_PROPERTY_SCALAR_GETTER(type) \
2729
    static void property_class_get_##type##_ptr(Object *obj, Visitor *v, \
2730
                                                const char *name, \
2731
                                                void *opaque, Error **errp) \
2732
23.7M
    { \
2733
23.7M
        type##_t value = *(type##_t *)object_class_prop_ptr(obj, \
2734
23.7M
                                                        (ptrdiff_t)opaque); \
2735
23.7M
        visit_type_##type(v, name, &value, errp); \
2736
23.7M
    }
object.c:property_class_get_uint8_ptr
Line
Count
Source
2732
212
    { \
2733
212
        type##_t value = *(type##_t *)object_class_prop_ptr(obj, \
2734
212
                                                        (ptrdiff_t)opaque); \
2735
212
        visit_type_##type(v, name, &value, errp); \
2736
212
    }
object.c:property_class_get_uint16_ptr
Line
Count
Source
2732
122
    { \
2733
122
        type##_t value = *(type##_t *)object_class_prop_ptr(obj, \
2734
122
                                                        (ptrdiff_t)opaque); \
2735
122
        visit_type_##type(v, name, &value, errp); \
2736
122
    }
object.c:property_class_get_uint32_ptr
Line
Count
Source
2732
23.7M
    { \
2733
23.7M
        type##_t value = *(type##_t *)object_class_prop_ptr(obj, \
2734
23.7M
                                                        (ptrdiff_t)opaque); \
2735
23.7M
        visit_type_##type(v, name, &value, errp); \
2736
23.7M
    }
object.c:property_class_get_uint64_ptr
Line
Count
Source
2732
53
    { \
2733
53
        type##_t value = *(type##_t *)object_class_prop_ptr(obj, \
2734
53
                                                        (ptrdiff_t)opaque); \
2735
53
        visit_type_##type(v, name, &value, errp); \
2736
53
    }
2737
2738
#define OBJECT_CLASS_PROPERTY_SCALAR_SETTER(type) \
2739
    static void property_class_set_##type##_ptr(Object *obj, Visitor *v, \
2740
                                                const char *name, \
2741
                                                void *opaque, Error **errp) \
2742
8
    { \
2743
8
        type##_t *field = (type##_t *)object_class_prop_ptr(obj, \
2744
8
                                                        (ptrdiff_t)opaque); \
2745
8
        type##_t value; \
2746
8
        \
2747
8
        if (!visit_type_##type(v, name, &value, errp)) { \
2748
0
            return; \
2749
0
        } \
2750
8
        \
2751
8
        *field = value; \
2752
8
    }
Unexecuted instantiation: object.c:property_class_set_uint8_ptr
Unexecuted instantiation: object.c:property_class_set_uint16_ptr
object.c:property_class_set_uint32_ptr
Line
Count
Source
2742
8
    { \
2743
8
        type##_t *field = (type##_t *)object_class_prop_ptr(obj, \
2744
8
                                                        (ptrdiff_t)opaque); \
2745
8
        type##_t value; \
2746
8
        \
2747
8
        if (!visit_type_##type(v, name, &value, errp)) { \
2748
0
            return; \
2749
0
        } \
2750
8
        \
2751
8
        *field = value; \
2752
8
    }
Unexecuted instantiation: object.c:property_class_set_uint64_ptr
2753
2754
#define DEFINE_OBJECT_CLASS_PROPERTY_SCALAR_METHODS(type) \
2755
    OBJECT_CLASS_PROPERTY_SCALAR_GETTER(type) \
2756
    OBJECT_CLASS_PROPERTY_SCALAR_SETTER(type)
2757
2758
DEFINE_OBJECT_CLASS_PROPERTY_SCALAR_METHODS(uint8)
2759
DEFINE_OBJECT_CLASS_PROPERTY_SCALAR_METHODS(uint16)
2760
DEFINE_OBJECT_CLASS_PROPERTY_SCALAR_METHODS(uint32)
2761
DEFINE_OBJECT_CLASS_PROPERTY_SCALAR_METHODS(uint64)
2762
2763
#undef OBJECT_CLASS_PROPERTY_SCALAR_GETTER
2764
#undef OBJECT_CLASS_PROPERTY_SCALAR_SETTER
2765
#undef DEFINE_OBJECT_CLASS_PROPERTY_SCALAR_METHODS
2766
2767
2768
static void property_class_get_bool_ptr(Object *obj, Visitor *v,
2769
                                        const char *name,
2770
                                        void *opaque, Error **errp)
2771
159
{
2772
159
    bool value = *(bool *)object_class_prop_ptr(obj, (ptrdiff_t)opaque);
2773
2774
159
    visit_type_bool(v, name, &value, errp);
2775
159
}
2776
2777
static void property_class_set_bool_ptr(Object *obj, Visitor *v,
2778
                                        const char *name,
2779
                                        void *opaque, Error **errp)
2780
0
{
2781
0
    bool *field = (bool *)object_class_prop_ptr(obj, (ptrdiff_t)opaque);
2782
0
    bool value;
2783
2784
0
    if (!visit_type_bool(v, name, &value, errp)) {
2785
0
        return;
2786
0
    }
2787
2788
0
    *field = value;
2789
0
}
2790
2791
ObjectProperty *
2792
object_class_property_add_bool_ptr(ObjectClass *klass, const char *name,
2793
                                   ptrdiff_t offset,
2794
                                   ObjectPropertyFlags flags)
2795
183
{
2796
183
    ObjectPropertyAccessor *getter = NULL;
2797
183
    ObjectPropertyAccessor *setter = NULL;
2798
2799
183
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2800
183
        getter = property_class_get_bool_ptr;
2801
183
    }
2802
2803
183
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2804
183
        setter = property_class_set_bool_ptr;
2805
183
    }
2806
2807
183
    return object_class_property_add(klass, name, "bool",
2808
183
                                     getter, setter, NULL, (void *)offset);
2809
183
}
2810
2811
ObjectProperty *
2812
object_property_add_uint8_ptr(Object *obj, const char *name,
2813
                              const uint8_t *v,
2814
                              ObjectPropertyFlags flags)
2815
0
{
2816
0
    ObjectPropertyAccessor *getter = NULL;
2817
0
    ObjectPropertyAccessor *setter = NULL;
2818
2819
0
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2820
0
        getter = property_get_uint8_ptr;
2821
0
    }
2822
2823
0
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2824
0
        setter = property_set_uint8_ptr;
2825
0
    }
2826
2827
0
    return object_property_add(obj, name, "uint8",
2828
0
                               getter, setter, NULL, (void *)v);
2829
0
}
2830
2831
ObjectProperty *
2832
object_class_property_add_uint8_ptr(ObjectClass *klass, const char *name,
2833
                                    ptrdiff_t offset,
2834
                                    ObjectPropertyFlags flags)
2835
244
{
2836
244
    ObjectPropertyAccessor *getter = NULL;
2837
244
    ObjectPropertyAccessor *setter = NULL;
2838
2839
244
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2840
244
        getter = property_class_get_uint8_ptr;
2841
244
    }
2842
2843
244
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2844
183
        setter = property_class_set_uint8_ptr;
2845
183
    }
2846
2847
244
    return object_class_property_add(klass, name, "uint8",
2848
244
                                     getter, setter, NULL, (void *)offset);
2849
244
}
2850
2851
ObjectProperty *
2852
object_class_static_property_add_uint8_ptr(ObjectClass *klass,
2853
                                           const char *name,
2854
                                           const uint8_t *v,
2855
                                           ObjectPropertyFlags flags)
2856
244
{
2857
244
    ObjectPropertyAccessor *getter = NULL;
2858
244
    ObjectPropertyAccessor *setter = NULL;
2859
2860
244
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2861
244
        getter = property_get_uint8_ptr;
2862
244
    }
2863
2864
244
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2865
0
        setter = property_set_uint8_ptr;
2866
0
    }
2867
2868
244
    return object_class_property_add(klass, name, "uint8",
2869
244
                                     getter, setter, NULL, (void *)v);
2870
244
}
2871
2872
ObjectProperty *
2873
object_property_add_uint16_ptr(Object *obj, const char *name,
2874
                               const uint16_t *v,
2875
                               ObjectPropertyFlags flags)
2876
0
{
2877
0
    ObjectPropertyAccessor *getter = NULL;
2878
0
    ObjectPropertyAccessor *setter = NULL;
2879
2880
0
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2881
0
        getter = property_get_uint16_ptr;
2882
0
    }
2883
2884
0
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2885
0
        setter = property_set_uint16_ptr;
2886
0
    }
2887
2888
0
    return object_property_add(obj, name, "uint16",
2889
0
                               getter, setter, NULL, (void *)v);
2890
0
}
2891
2892
ObjectProperty *
2893
object_class_property_add_uint16_ptr(ObjectClass *klass, const char *name,
2894
                                     ptrdiff_t offset,
2895
                                     ObjectPropertyFlags flags)
2896
366
{
2897
366
    ObjectPropertyAccessor *getter = NULL;
2898
366
    ObjectPropertyAccessor *setter = NULL;
2899
2900
366
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2901
366
        getter = property_class_get_uint16_ptr;
2902
366
    }
2903
2904
366
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2905
0
        setter = property_class_set_uint16_ptr;
2906
0
    }
2907
2908
366
    return object_class_property_add(klass, name, "uint16",
2909
366
                                     getter, setter, NULL, (void *)offset);
2910
366
}
2911
2912
ObjectProperty *
2913
object_class_static_property_add_uint16_ptr(ObjectClass *klass,
2914
                                            const char *name,
2915
                                            const uint16_t *v,
2916
                                            ObjectPropertyFlags flags)
2917
61
{
2918
61
    ObjectPropertyAccessor *getter = NULL;
2919
61
    ObjectPropertyAccessor *setter = NULL;
2920
2921
61
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2922
61
        getter = property_get_uint16_ptr;
2923
61
    }
2924
2925
61
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2926
0
        setter = property_set_uint16_ptr;
2927
0
    }
2928
2929
61
    return object_class_property_add(klass, name, "uint16",
2930
61
                                     getter, setter, NULL, (void *)v);
2931
61
}
2932
2933
ObjectProperty *
2934
object_property_add_uint32_ptr(Object *obj, const char *name,
2935
                               const uint32_t *v,
2936
                               ObjectPropertyFlags flags)
2937
0
{
2938
0
    ObjectPropertyAccessor *getter = NULL;
2939
0
    ObjectPropertyAccessor *setter = NULL;
2940
2941
0
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2942
0
        getter = property_get_uint32_ptr;
2943
0
    }
2944
2945
0
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2946
0
        setter = property_set_uint32_ptr;
2947
0
    }
2948
2949
0
    return object_property_add(obj, name, "uint32",
2950
0
                               getter, setter, NULL, (void *)v);
2951
0
}
2952
2953
ObjectProperty *
2954
object_class_property_add_uint32_ptr(ObjectClass *klass, const char *name,
2955
                                     ptrdiff_t offset,
2956
                                     ObjectPropertyFlags flags)
2957
183
{
2958
183
    ObjectPropertyAccessor *getter = NULL;
2959
183
    ObjectPropertyAccessor *setter = NULL;
2960
2961
183
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2962
183
        getter = property_class_get_uint32_ptr;
2963
183
    }
2964
2965
183
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2966
61
        setter = property_class_set_uint32_ptr;
2967
61
    }
2968
2969
183
    return object_class_property_add(klass, name, "uint32",
2970
183
                                     getter, setter, NULL, (void *)offset);
2971
183
}
2972
2973
ObjectProperty *
2974
object_class_static_property_add_uint32_ptr(ObjectClass *klass,
2975
                                            const char *name,
2976
                                            const uint32_t *v,
2977
                                            ObjectPropertyFlags flags)
2978
183
{
2979
183
    ObjectPropertyAccessor *getter = NULL;
2980
183
    ObjectPropertyAccessor *setter = NULL;
2981
2982
183
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
2983
183
        getter = property_get_uint32_ptr;
2984
183
    }
2985
2986
183
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
2987
0
        setter = property_set_uint32_ptr;
2988
0
    }
2989
2990
183
    return object_class_property_add(klass, name, "uint32",
2991
183
                                     getter, setter, NULL, (void *)v);
2992
183
}
2993
2994
ObjectProperty *
2995
object_property_add_uint64_ptr(Object *obj, const char *name,
2996
                               const uint64_t *v,
2997
                               ObjectPropertyFlags flags)
2998
8.05M
{
2999
8.05M
    ObjectPropertyAccessor *getter = NULL;
3000
8.05M
    ObjectPropertyAccessor *setter = NULL;
3001
3002
8.05M
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
3003
8.05M
        getter = property_get_uint64_ptr;
3004
8.05M
    }
3005
3006
8.05M
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
3007
0
        setter = property_set_uint64_ptr;
3008
0
    }
3009
3010
8.05M
    return object_property_add(obj, name, "uint64",
3011
8.05M
                               getter, setter, NULL, (void *)v);
3012
8.05M
}
3013
3014
ObjectProperty *
3015
object_class_property_add_uint64_ptr(ObjectClass *klass, const char *name,
3016
                                     ptrdiff_t offset,
3017
                                     ObjectPropertyFlags flags)
3018
61
{
3019
61
    ObjectPropertyAccessor *getter = NULL;
3020
61
    ObjectPropertyAccessor *setter = NULL;
3021
3022
61
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
3023
61
        getter = property_class_get_uint64_ptr;
3024
61
    }
3025
3026
61
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
3027
0
        setter = property_class_set_uint64_ptr;
3028
0
    }
3029
3030
61
    return object_class_property_add(klass, name, "uint64",
3031
61
                                     getter, setter, NULL, (void *)offset);
3032
61
}
3033
3034
ObjectProperty *
3035
object_class_static_property_add_uint64_ptr(ObjectClass *klass,
3036
                                            const char *name,
3037
                                            const uint64_t *v,
3038
                                            ObjectPropertyFlags flags)
3039
0
{
3040
0
    ObjectPropertyAccessor *getter = NULL;
3041
0
    ObjectPropertyAccessor *setter = NULL;
3042
3043
0
    if ((flags & OBJ_PROP_FLAG_READ) == OBJ_PROP_FLAG_READ) {
3044
0
        getter = property_get_uint64_ptr;
3045
0
    }
3046
3047
0
    if ((flags & OBJ_PROP_FLAG_WRITE) == OBJ_PROP_FLAG_WRITE) {
3048
0
        setter = property_set_uint64_ptr;
3049
0
    }
3050
3051
0
    return object_class_property_add(klass, name, "uint64",
3052
0
                                     getter, setter, NULL, (void *)v);
3053
0
}
3054
3055
typedef struct {
3056
    union {
3057
        Object *target_obj; /* if !OBJ_PROP_ALIAS_CLASS */
3058
        ptrdiff_t offset;   /* if OBJ_PROP_ALIAS_CLASS */
3059
    };
3060
    char *target_name;
3061
    ObjectPropertyAliasFlags flags;
3062
} AliasProperty;
3063
3064
static Object **
3065
object_alias_get_targetp(Object *obj, AliasProperty *aprop)
3066
263
{
3067
263
    if (aprop->flags & OBJ_PROP_ALIAS_CLASS) {
3068
244
        return (void *)obj + aprop->offset;
3069
244
    } else {
3070
19
        return &aprop->target_obj;
3071
19
    }
3072
263
}
3073
3074
static void property_get_alias(Object *obj, Visitor *v, const char *name,
3075
                               void *opaque, Error **errp)
3076
0
{
3077
0
    AliasProperty *prop = opaque;
3078
0
    Object **target_obj = object_alias_get_targetp(obj, prop);
3079
3080
0
    if (*target_obj) {
3081
0
        Visitor *alias_v = visitor_forward_field(v, prop->target_name, name);
3082
3083
0
        object_property_get(*target_obj, prop->target_name, alias_v, errp);
3084
0
        visit_free(alias_v);
3085
0
    } else {
3086
0
        QNull *null = NULL;
3087
3088
0
        visit_type_null(v, NULL, &null, errp);
3089
0
        qnull_unref(null);
3090
0
    }
3091
0
}
3092
3093
static void property_set_alias(Object *obj, Visitor *v, const char *name,
3094
                               void *opaque, Error **errp)
3095
19
{
3096
19
    AliasProperty *prop = opaque;
3097
19
    Object **target_obj = object_alias_get_targetp(obj, prop);
3098
3099
19
    if (*target_obj) {
3100
19
        Visitor *alias_v = visitor_forward_field(v, prop->target_name, name);
3101
3102
19
        object_property_set(*target_obj, prop->target_name, alias_v, errp);
3103
19
        visit_free(alias_v);
3104
19
    } else {
3105
0
        error_setg(errp, "unable to resolve alias property target");
3106
0
    }
3107
19
}
3108
3109
static Object *property_resolve_alias(Object *obj, void *opaque,
3110
                                      const char *part)
3111
0
{
3112
0
    AliasProperty *prop = opaque;
3113
0
    Object **target_obj = object_alias_get_targetp(obj, prop);
3114
3115
0
    if (*target_obj) {
3116
0
        return object_resolve_path_component(*target_obj, prop->target_name);
3117
0
    } else {
3118
0
        return NULL;
3119
0
    }
3120
0
}
3121
3122
static void property_release_alias(Object *obj, const char *name, void *opaque)
3123
12.0k
{
3124
12.0k
    AliasProperty *prop = opaque;
3125
3126
12.0k
    if (!(prop->flags & OBJ_PROP_ALIAS_CLASS)) {
3127
12.0k
        g_free(prop->target_name);
3128
12.0k
        g_free(prop);
3129
12.0k
    } else {
3130
0
        Object **target_obj = object_alias_get_targetp(obj, prop);
3131
3132
0
        if (*target_obj) {
3133
0
            ObjectProperty *target_prop = object_property_find_err(*target_obj,
3134
0
                                                           prop->target_name,
3135
0
                                                           &error_abort);
3136
0
            if (*target_obj != obj &&
3137
0
                !object_property_is_child(target_prop)) {
3138
0
                    object_unref(*target_obj);
3139
0
            }
3140
0
        }
3141
0
    }
3142
12.0k
}
3143
3144
ObjectProperty *
3145
object_property_add_alias(Object *obj, const char *name,
3146
                          Object *target_obj, const char *target_name)
3147
14.5k
{
3148
14.5k
    AliasProperty *prop;
3149
14.5k
    ObjectProperty *op;
3150
14.5k
    ObjectProperty *target_prop;
3151
14.5k
    g_autofree char *prop_type = NULL;
3152
3153
14.5k
    target_prop = object_property_find_err(target_obj, target_name,
3154
14.5k
                                           &error_abort);
3155
3156
14.5k
    if (object_property_is_child(target_prop)) {
3157
0
        prop_type = g_strdup_printf("link%s",
3158
0
                                    target_prop->type + strlen("child"));
3159
14.5k
    } else {
3160
14.5k
        prop_type = g_strdup(target_prop->type);
3161
14.5k
    }
3162
3163
14.5k
    prop = g_malloc(sizeof(*prop));
3164
14.5k
    prop->target_obj = target_obj;
3165
14.5k
    prop->target_name = g_strdup(target_name);
3166
14.5k
    prop->flags = 0;
3167
3168
14.5k
    op = object_property_add(obj, name, prop_type,
3169
14.5k
                             property_get_alias,
3170
14.5k
                             property_set_alias,
3171
14.5k
                             property_release_alias,
3172
14.5k
                             prop);
3173
14.5k
    op->resolve = property_resolve_alias;
3174
14.5k
    if (target_prop->defval) {
3175
11.6k
        op->defval = qobject_ref(target_prop->defval);
3176
11.6k
    }
3177
3178
14.5k
    object_property_set_description(obj, op->name,
3179
14.5k
                                    target_prop->description);
3180
14.5k
    return op;
3181
14.5k
}
3182
3183
ObjectProperty *
3184
object_class_property_add_alias(ObjectClass *klass, const char *name,
3185
                                ptrdiff_t offset,
3186
                                const char *target_type,
3187
                                const char *target_name)
3188
244
{
3189
244
    AliasProperty *prop;
3190
244
    ObjectProperty *op;
3191
244
    ObjectProperty *target_prop;
3192
244
    ObjectClass *target_class;
3193
244
    g_autofree char *prop_type = NULL;
3194
3195
244
    target_class = object_class_by_name(target_type);
3196
244
    assert(target_class);
3197
244
    target_prop = object_class_property_find(target_class, target_name);
3198
244
    assert(target_prop);
3199
3200
244
    if (object_property_is_child(target_prop)) {
3201
0
        prop_type = g_strdup_printf("link%s",
3202
0
                                    target_prop->type + strlen("child"));
3203
244
    } else {
3204
244
        prop_type = g_strdup(target_prop->type);
3205
244
    }
3206
3207
244
    prop = g_malloc(sizeof(*prop));
3208
244
    prop->offset = offset;
3209
244
    prop->target_name = g_strdup(target_name);
3210
244
    prop->flags = OBJ_PROP_ALIAS_CLASS;
3211
3212
244
    op = object_class_property_add(klass, name, prop_type,
3213
244
                                   property_get_alias,
3214
244
                                   property_set_alias,
3215
244
                                   property_release_alias,
3216
244
                                   prop);
3217
244
    op->resolve = property_resolve_alias;
3218
244
    if (target_prop->defval) {
3219
0
        op->defval = qobject_ref(target_prop->defval);
3220
0
    }
3221
3222
244
    object_class_property_set_description(klass, op->name,
3223
244
                                          target_prop->description);
3224
244
    return op;
3225
244
}
3226
3227
void object_property_set_alias(Object *obj, const char *name,
3228
                               Object *target_obj)
3229
244
{
3230
244
    AliasProperty *prop;
3231
244
    ObjectProperty *op, *target_prop;
3232
244
    Object **target_objp;
3233
3234
244
    op = object_property_find_err(obj, name, &error_abort);
3235
244
    prop = op->opaque;
3236
244
    assert(prop->flags & OBJ_PROP_ALIAS_CLASS);
3237
3238
244
    target_objp = object_alias_get_targetp(obj, prop);
3239
244
    if (*target_objp) {
3240
0
        target_prop = object_property_find_err(*target_objp, prop->target_name,
3241
0
                                               &error_abort);
3242
0
        if (*target_objp != obj && !object_property_is_child(target_prop)) {
3243
0
            object_unref(*target_objp);
3244
0
        }
3245
0
    }
3246
244
    *target_objp = target_obj;
3247
244
    if (*target_objp) {
3248
244
        target_prop = object_property_find_err(*target_objp, prop->target_name,
3249
244
                                               &error_abort);
3250
244
        if (*target_objp != obj && !object_property_is_child(target_prop)) {
3251
244
            object_ref(*target_objp);
3252
244
        }
3253
244
    }
3254
244
}
3255
3256
void object_property_set_description(Object *obj, const char *name,
3257
                                     const char *description)
3258
14.9k
{
3259
14.9k
    ObjectProperty *op;
3260
3261
14.9k
    op = object_property_find_err(obj, name, &error_abort);
3262
14.9k
    g_free(op->description);
3263
14.9k
    op->description = g_strdup(description);
3264
14.9k
}
3265
3266
void object_class_property_set_description(ObjectClass *klass,
3267
                                           const char *name,
3268
                                           const char *description)
3269
95.2k
{
3270
95.2k
    ObjectProperty *op;
3271
3272
95.2k
    op = g_hash_table_lookup(klass->properties, name);
3273
95.2k
    g_free(op->description);
3274
95.2k
    op->description = g_strdup(description);
3275
95.2k
}
3276
3277
bool object_class_check_security(ObjectClass *klass, Error **errp)
3278
223
{
3279
223
    return compat_policy_check_security(&compat_policy,
3280
223
                                        object_class_get_name(klass),
3281
223
                                        object_class_is_secure(klass),
3282
223
                                        errp);
3283
223
}
3284
3285
static void object_class_init(ObjectClass *klass, const void *data)
3286
61
{
3287
61
    object_class_property_add_str(klass, "type", object_get_type,
3288
61
                                  NULL);
3289
61
}
3290
3291
static void __attribute__((constructor)) register_types(void)
3292
61
{
3293
61
    static const TypeInfo interface_info = {
3294
61
        .name = TYPE_INTERFACE,
3295
61
        .class_size = sizeof(InterfaceClass),
3296
61
        .abstract = true,
3297
61
    };
3298
3299
61
    static const TypeInfo object_info = {
3300
61
        .name = TYPE_OBJECT,
3301
61
        .instance_size = sizeof(Object),
3302
61
        .class_init = object_class_init,
3303
61
        .abstract = true,
3304
61
    };
3305
3306
61
    type_table = g_hash_table_new(g_str_hash, g_str_equal);
3307
61
    type_interface = type_register_internal(&interface_info);
3308
61
    type_register_internal(&object_info);
3309
61
}