]>
Commit | Line | Data |
---|---|---|
2f28d2ff AL |
1 | /* |
2 | * QEMU Object Model | |
3 | * | |
4 | * Copyright IBM, Corp. 2011 | |
5 | * | |
6 | * Authors: | |
7 | * Anthony Liguori <aliguori@us.ibm.com> | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
10 | * See the COPYING file in the top-level directory. | |
11 | */ | |
12 | ||
13 | #include "qemu/object.h" | |
14 | #include "qemu-common.h" | |
15 | ||
16 | #define MAX_INTERFACES 32 | |
17 | ||
18 | typedef struct InterfaceImpl InterfaceImpl; | |
19 | typedef struct TypeImpl TypeImpl; | |
20 | ||
21 | struct InterfaceImpl | |
22 | { | |
23 | const char *parent; | |
24 | void (*interface_initfn)(ObjectClass *class, void *data); | |
25 | TypeImpl *type; | |
26 | }; | |
27 | ||
28 | struct TypeImpl | |
29 | { | |
30 | const char *name; | |
31 | ||
32 | size_t class_size; | |
33 | ||
34 | size_t instance_size; | |
35 | ||
36 | void (*class_init)(ObjectClass *klass, void *data); | |
37 | void (*class_finalize)(ObjectClass *klass, void *data); | |
38 | ||
39 | void *class_data; | |
40 | ||
41 | void (*instance_init)(Object *obj); | |
42 | void (*instance_finalize)(Object *obj); | |
43 | ||
44 | bool abstract; | |
45 | ||
46 | const char *parent; | |
47 | TypeImpl *parent_type; | |
48 | ||
49 | ObjectClass *class; | |
50 | ||
51 | int num_interfaces; | |
52 | InterfaceImpl interfaces[MAX_INTERFACES]; | |
53 | }; | |
54 | ||
55 | typedef struct Interface | |
56 | { | |
57 | Object parent; | |
58 | Object *obj; | |
59 | } Interface; | |
60 | ||
61 | #define INTERFACE(obj) OBJECT_CHECK(Interface, obj, TYPE_INTERFACE) | |
62 | ||
63 | static GHashTable *type_table_get(void) | |
64 | { | |
65 | static GHashTable *type_table; | |
66 | ||
67 | if (type_table == NULL) { | |
68 | type_table = g_hash_table_new(g_str_hash, g_str_equal); | |
69 | } | |
70 | ||
71 | return type_table; | |
72 | } | |
73 | ||
74 | static void type_table_add(TypeImpl *ti) | |
75 | { | |
76 | g_hash_table_insert(type_table_get(), (void *)ti->name, ti); | |
77 | } | |
78 | ||
79 | static TypeImpl *type_table_lookup(const char *name) | |
80 | { | |
81 | return g_hash_table_lookup(type_table_get(), name); | |
82 | } | |
83 | ||
84 | TypeImpl *type_register(const TypeInfo *info) | |
85 | { | |
86 | TypeImpl *ti = g_malloc0(sizeof(*ti)); | |
87 | ||
88 | g_assert(info->name != NULL); | |
89 | ||
90 | ti->name = g_strdup(info->name); | |
91 | ti->parent = g_strdup(info->parent); | |
92 | ||
93 | ti->class_size = info->class_size; | |
94 | ti->instance_size = info->instance_size; | |
95 | ||
96 | ti->class_init = info->class_init; | |
97 | ti->class_finalize = info->class_finalize; | |
98 | ti->class_data = info->class_data; | |
99 | ||
100 | ti->instance_init = info->instance_init; | |
101 | ti->instance_finalize = info->instance_finalize; | |
102 | ||
103 | ti->abstract = info->abstract; | |
104 | ||
105 | if (info->interfaces) { | |
106 | int i; | |
107 | ||
108 | for (i = 0; info->interfaces[i].type; i++) { | |
109 | ti->interfaces[i].parent = info->interfaces[i].type; | |
110 | ti->interfaces[i].interface_initfn = info->interfaces[i].interface_initfn; | |
111 | ti->num_interfaces++; | |
112 | } | |
113 | } | |
114 | ||
115 | type_table_add(ti); | |
116 | ||
117 | return ti; | |
118 | } | |
119 | ||
120 | TypeImpl *type_register_static(const TypeInfo *info) | |
121 | { | |
122 | return type_register(info); | |
123 | } | |
124 | ||
125 | static TypeImpl *type_get_by_name(const char *name) | |
126 | { | |
127 | if (name == NULL) { | |
128 | return NULL; | |
129 | } | |
130 | ||
131 | return type_table_lookup(name); | |
132 | } | |
133 | ||
134 | static TypeImpl *type_get_parent(TypeImpl *type) | |
135 | { | |
136 | if (!type->parent_type && type->parent) { | |
137 | type->parent_type = type_get_by_name(type->parent); | |
138 | g_assert(type->parent_type != NULL); | |
139 | } | |
140 | ||
141 | return type->parent_type; | |
142 | } | |
143 | ||
144 | static bool type_has_parent(TypeImpl *type) | |
145 | { | |
146 | return (type->parent != NULL); | |
147 | } | |
148 | ||
149 | static size_t type_class_get_size(TypeImpl *ti) | |
150 | { | |
151 | if (ti->class_size) { | |
152 | return ti->class_size; | |
153 | } | |
154 | ||
155 | if (type_has_parent(ti)) { | |
156 | return type_class_get_size(type_get_parent(ti)); | |
157 | } | |
158 | ||
159 | return sizeof(ObjectClass); | |
160 | } | |
161 | ||
162 | static void type_class_interface_init(TypeImpl *ti, InterfaceImpl *iface) | |
163 | { | |
164 | TypeInfo info = { | |
165 | .instance_size = sizeof(Interface), | |
166 | .parent = iface->parent, | |
167 | .class_size = sizeof(InterfaceClass), | |
168 | .class_init = iface->interface_initfn, | |
169 | .abstract = true, | |
170 | }; | |
171 | char *name = g_strdup_printf("<%s::%s>", ti->name, iface->parent); | |
172 | ||
173 | info.name = name; | |
174 | iface->type = type_register(&info); | |
175 | g_free(name); | |
176 | } | |
177 | ||
178 | static void type_class_init(TypeImpl *ti) | |
179 | { | |
180 | size_t class_size = sizeof(ObjectClass); | |
181 | int i; | |
182 | ||
183 | if (ti->class) { | |
184 | return; | |
185 | } | |
186 | ||
187 | ti->class_size = type_class_get_size(ti); | |
188 | ||
189 | ti->class = g_malloc0(ti->class_size); | |
190 | ti->class->type = ti; | |
191 | ||
192 | if (type_has_parent(ti)) { | |
193 | TypeImpl *parent = type_get_parent(ti); | |
194 | ||
195 | type_class_init(parent); | |
196 | ||
197 | class_size = parent->class_size; | |
198 | g_assert(parent->class_size <= ti->class_size); | |
199 | ||
200 | memcpy((void *)ti->class + sizeof(ObjectClass), | |
201 | (void *)parent->class + sizeof(ObjectClass), | |
202 | parent->class_size - sizeof(ObjectClass)); | |
203 | } | |
204 | ||
205 | memset((void *)ti->class + class_size, 0, ti->class_size - class_size); | |
206 | ||
207 | for (i = 0; i < ti->num_interfaces; i++) { | |
208 | type_class_interface_init(ti, &ti->interfaces[i]); | |
209 | } | |
210 | ||
211 | if (ti->class_init) { | |
212 | ti->class_init(ti->class, ti->class_data); | |
213 | } | |
214 | } | |
215 | ||
216 | static void object_interface_init(Object *obj, InterfaceImpl *iface) | |
217 | { | |
218 | TypeImpl *ti = iface->type; | |
219 | Interface *iface_obj; | |
220 | ||
221 | iface_obj = INTERFACE(object_new(ti->name)); | |
222 | iface_obj->obj = obj; | |
223 | ||
224 | obj->interfaces = g_slist_prepend(obj->interfaces, iface_obj); | |
225 | } | |
226 | ||
227 | static void object_init_with_type(Object *obj, TypeImpl *ti) | |
228 | { | |
229 | int i; | |
230 | ||
231 | if (type_has_parent(ti)) { | |
232 | object_init_with_type(obj, type_get_parent(ti)); | |
233 | } | |
234 | ||
235 | for (i = 0; i < ti->num_interfaces; i++) { | |
236 | object_interface_init(obj, &ti->interfaces[i]); | |
237 | } | |
238 | ||
239 | if (ti->instance_init) { | |
240 | ti->instance_init(obj); | |
241 | } | |
242 | } | |
243 | ||
244 | void object_initialize_with_type(void *data, TypeImpl *type) | |
245 | { | |
246 | Object *obj = data; | |
247 | ||
248 | g_assert(type != NULL); | |
249 | g_assert(type->instance_size >= sizeof(ObjectClass)); | |
250 | ||
251 | type_class_init(type); | |
252 | g_assert(type->abstract == false); | |
253 | ||
254 | memset(obj, 0, type->instance_size); | |
255 | obj->class = type->class; | |
256 | object_init_with_type(obj, type); | |
257 | } | |
258 | ||
259 | void object_initialize(void *data, const char *typename) | |
260 | { | |
261 | TypeImpl *type = type_get_by_name(typename); | |
262 | ||
263 | object_initialize_with_type(data, type); | |
264 | } | |
265 | ||
266 | static void object_deinit(Object *obj, TypeImpl *type) | |
267 | { | |
268 | if (type->instance_finalize) { | |
269 | type->instance_finalize(obj); | |
270 | } | |
271 | ||
272 | while (obj->interfaces) { | |
273 | Interface *iface_obj = obj->interfaces->data; | |
274 | obj->interfaces = g_slist_delete_link(obj->interfaces, obj->interfaces); | |
275 | object_delete(OBJECT(iface_obj)); | |
276 | } | |
277 | ||
278 | if (type_has_parent(type)) { | |
279 | object_deinit(obj, type_get_parent(type)); | |
280 | } | |
281 | } | |
282 | ||
283 | void object_finalize(void *data) | |
284 | { | |
285 | Object *obj = data; | |
286 | TypeImpl *ti = obj->class->type; | |
287 | ||
288 | object_deinit(obj, ti); | |
289 | } | |
290 | ||
291 | Object *object_new_with_type(Type type) | |
292 | { | |
293 | Object *obj; | |
294 | ||
295 | g_assert(type != NULL); | |
296 | ||
297 | obj = g_malloc(type->instance_size); | |
298 | object_initialize_with_type(obj, type); | |
299 | ||
300 | return obj; | |
301 | } | |
302 | ||
303 | Object *object_new(const char *typename) | |
304 | { | |
305 | TypeImpl *ti = type_get_by_name(typename); | |
306 | ||
307 | return object_new_with_type(ti); | |
308 | } | |
309 | ||
310 | void object_delete(Object *obj) | |
311 | { | |
312 | object_finalize(obj); | |
313 | g_free(obj); | |
314 | } | |
315 | ||
316 | static bool object_is_type(Object *obj, const char *typename) | |
317 | { | |
318 | TypeImpl *target_type = type_get_by_name(typename); | |
319 | TypeImpl *type = obj->class->type; | |
320 | GSList *i; | |
321 | ||
322 | /* Check if typename is a direct ancestor of type */ | |
323 | while (type) { | |
324 | if (type == target_type) { | |
325 | return true; | |
326 | } | |
327 | ||
328 | type = type_get_parent(type); | |
329 | } | |
330 | ||
331 | /* Check if obj has an interface of typename */ | |
332 | for (i = obj->interfaces; i; i = i->next) { | |
333 | Interface *iface = i->data; | |
334 | ||
335 | if (object_is_type(OBJECT(iface), typename)) { | |
336 | return true; | |
337 | } | |
338 | } | |
339 | ||
340 | return false; | |
341 | } | |
342 | ||
343 | Object *object_dynamic_cast(Object *obj, const char *typename) | |
344 | { | |
345 | GSList *i; | |
346 | ||
347 | /* Check if typename is a direct ancestor */ | |
348 | if (object_is_type(obj, typename)) { | |
349 | return obj; | |
350 | } | |
351 | ||
352 | /* Check if obj has an interface of typename */ | |
353 | for (i = obj->interfaces; i; i = i->next) { | |
354 | Interface *iface = i->data; | |
355 | ||
356 | if (object_is_type(OBJECT(iface), typename)) { | |
357 | return OBJECT(iface); | |
358 | } | |
359 | } | |
360 | ||
361 | /* Check if obj is an interface and its containing object is a direct | |
362 | * ancestor of typename */ | |
363 | if (object_is_type(obj, TYPE_INTERFACE)) { | |
364 | Interface *iface = INTERFACE(obj); | |
365 | ||
366 | if (object_is_type(iface->obj, typename)) { | |
367 | return iface->obj; | |
368 | } | |
369 | } | |
370 | ||
371 | return NULL; | |
372 | } | |
373 | ||
374 | ||
375 | static void register_interface(void) | |
376 | { | |
377 | static TypeInfo interface_info = { | |
378 | .name = TYPE_INTERFACE, | |
379 | .instance_size = sizeof(Interface), | |
380 | .abstract = true, | |
381 | }; | |
382 | ||
383 | type_register_static(&interface_info); | |
384 | } | |
385 | ||
386 | device_init(register_interface); | |
387 | ||
388 | Object *object_dynamic_cast_assert(Object *obj, const char *typename) | |
389 | { | |
390 | Object *inst; | |
391 | ||
392 | inst = object_dynamic_cast(obj, typename); | |
393 | ||
394 | if (!inst) { | |
395 | fprintf(stderr, "Object %p is not an instance of type %s\n", | |
396 | obj, typename); | |
397 | abort(); | |
398 | } | |
399 | ||
400 | return inst; | |
401 | } | |
402 | ||
403 | ObjectClass *object_class_dynamic_cast(ObjectClass *class, | |
404 | const char *typename) | |
405 | { | |
406 | TypeImpl *target_type = type_get_by_name(typename); | |
407 | TypeImpl *type = class->type; | |
408 | ||
409 | while (type) { | |
410 | if (type == target_type) { | |
411 | return class; | |
412 | } | |
413 | ||
414 | type = type_get_parent(type); | |
415 | } | |
416 | ||
417 | return NULL; | |
418 | } | |
419 | ||
420 | ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class, | |
421 | const char *typename) | |
422 | { | |
423 | ObjectClass *ret = object_class_dynamic_cast(class, typename); | |
424 | ||
425 | if (!ret) { | |
426 | fprintf(stderr, "Object %p is not an instance of type %s\n", | |
427 | class, typename); | |
428 | abort(); | |
429 | } | |
430 | ||
431 | return ret; | |
432 | } | |
433 | ||
434 | const char *object_get_typename(Object *obj) | |
435 | { | |
436 | return obj->class->type->name; | |
437 | } | |
438 | ||
439 | ObjectClass *object_get_class(Object *obj) | |
440 | { | |
441 | return obj->class; | |
442 | } | |
443 | ||
444 | const char *object_class_get_name(ObjectClass *klass) | |
445 | { | |
446 | return klass->type->name; | |
447 | } | |
448 | ||
449 | ObjectClass *object_class_by_name(const char *typename) | |
450 | { | |
451 | TypeImpl *type = type_get_by_name(typename); | |
452 | ||
453 | if (!type) { | |
454 | return NULL; | |
455 | } | |
456 | ||
457 | type_class_init(type); | |
458 | ||
459 | return type->class; | |
460 | } | |
461 | ||
462 | typedef struct OCFData | |
463 | { | |
464 | void (*fn)(ObjectClass *klass, void *opaque); | |
465 | void *opaque; | |
466 | } OCFData; | |
467 | ||
468 | static void object_class_foreach_tramp(gpointer key, gpointer value, | |
469 | gpointer opaque) | |
470 | { | |
471 | OCFData *data = opaque; | |
472 | TypeImpl *type = value; | |
473 | ||
474 | type_class_init(type); | |
475 | ||
476 | data->fn(value, type->class); | |
477 | } | |
478 | ||
479 | void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque), | |
480 | void *opaque) | |
481 | { | |
482 | OCFData data = { fn, opaque }; | |
483 | ||
484 | g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data); | |
485 | } |