qom/type.c

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