When initializing all types in object_class_foreach, called by
object_class_get_list,
some new types may be registered. Those will change the type internal hashtable
which
is currently enumerated, and may crash QEMU.
Fix it, by adding a second hash table which contains all the non-initialized
types,
merged to the main one before each round of initializations.
Bug has been detected when registering dynamic types containing an interface.
Signed-off-by: Hervé Poussineau <hpous...@reactos.org>
---
qom/object.c | 45 +++++++++++++++++++++++++++++++++++++--------
1 file changed, 37 insertions(+), 8 deletions(-)
diff --git a/qom/object.c b/qom/object.c
index 75e6aac..e0a24dc 100644
--- a/qom/object.c
+++ b/qom/object.c
@@ -65,25 +65,39 @@ struct TypeImpl
static Type type_interface;
+static GHashTable *type_table_to_initialize;
+static GHashTable *type_table_initialized;
+
static GHashTable *type_table_get(void)
{
- static GHashTable *type_table;
-
- if (type_table == NULL) {
- type_table = g_hash_table_new(g_str_hash, g_str_equal);
+ if (!type_table_initialized) {
+ type_table_initialized = g_hash_table_new(g_str_hash, g_str_equal);
}
- return type_table;
+ return type_table_initialized;
}
static void type_table_add(TypeImpl *ti)
{
- g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
+ GHashTable **type_table;
+ if (ti->class) {
+ type_table = &type_table_initialized;
+ } else {
+ type_table = &type_table_to_initialize;
+ }
+ if (!*type_table) {
+ *type_table = g_hash_table_new(g_str_hash, g_str_equal);
+ }
+ g_hash_table_insert(*type_table, (void *)ti->name, ti);
}
static TypeImpl *type_table_lookup(const char *name)
{
- return g_hash_table_lookup(type_table_get(), name);
+ TypeImpl *ret = g_hash_table_lookup(type_table_get(), name);
+ if (!ret && type_table_to_initialize) {
+ ret = g_hash_table_lookup(type_table_to_initialize, name);
+ }
+ return ret;
}
static TypeImpl *type_register_internal(const TypeInfo *info)
@@ -573,13 +587,28 @@ static void object_class_foreach_tramp(gpointer key,
gpointer value,
data->fn(k, data->opaque);
}
+static void object_class_merge(gpointer key, gpointer value,
+ gpointer opaque)
+{
+ g_hash_table_insert(type_table_get(), key, value);
+}
+
void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
const char *implements_type, bool include_abstract,
void *opaque)
{
OCFData data = { fn, implements_type, include_abstract, opaque };
- g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data);
+ while (type_table_to_initialize &&
+ g_hash_table_size(type_table_to_initialize) > 0) {
+ g_hash_table_foreach(type_table_to_initialize, object_class_merge,
+ NULL);
+ g_hash_table_destroy(type_table_to_initialize);
+ type_table_to_initialize = NULL;
+
+ g_hash_table_foreach(type_table_get(), object_class_foreach_tramp,
+ &data);
+ }
}
int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
--
1.7.10.4
