/* Lookup AccelClass from opt_name. Returns NULL if not found */ static AccelClass *accel_find(const char *opt_name) { char *class_name = g_strdup_printf(ACCEL_CLASS_NAME("%s"), opt_name); AccelClass *ac = ACCEL_CLASS(object_class_by_name(class_name)); g_free(class_name); return ac; }
static void test_dummy_class_iterator(void) { ObjectPropertyIterator iter; ObjectClass *klass = object_class_by_name(TYPE_DUMMY); object_class_property_iter_init(&iter, klass); test_dummy_prop_iterator(&iter); }
static const char *pnv_core_cpu_typename(PnvCore *pc) { const char *core_type = object_class_get_name(object_get_class(OBJECT(pc))); int len = strlen(core_type) - strlen(PNV_CORE_TYPE_SUFFIX); char *s = g_strdup_printf(POWERPC_CPU_TYPE_NAME("%.*s"), len, core_type); const char *cpu_type = object_class_get_name(object_class_by_name(s)); g_free(s); return cpu_type; }
static const char *pnv_chip_core_typename(const PnvChip *o) { const char *chip_type = object_class_get_name(object_get_class(OBJECT(o))); int len = strlen(chip_type) - strlen(PNV_CHIP_TYPE_SUFFIX); char *s = g_strdup_printf(PNV_CORE_TYPE_NAME("%.*s"), len, chip_type); const char *core_type = object_class_get_name(object_class_by_name(s)); g_free(s); return core_type; }
/* * Return the sPAPR CPU core type for @model which essentially is the CPU * model specified with -cpu cmdline option. */ const char *spapr_get_cpu_core_type(const char *cpu_type) { int len = strlen(cpu_type) - strlen(POWERPC_CPU_TYPE_SUFFIX); char *core_type = g_strdup_printf(SPAPR_CPU_CORE_TYPE_NAME("%.*s"), len, cpu_type); ObjectClass *oc = object_class_by_name(core_type); g_free(core_type); if (!oc) { return NULL; } return object_class_get_name(oc); }
static ObjectClass *moxie_cpu_class_by_name(const char *cpu_model) { ObjectClass *oc; if (cpu_model == NULL) { return NULL; } oc = object_class_by_name(cpu_model); if (oc != NULL && (!object_class_dynamic_cast(oc, TYPE_MOXIE_CPU) || object_class_is_abstract(oc))) { return NULL; } return oc; }
/* Return a DevicePropertyInfo for a qdev property. * * If a qdev property with the given name does not exist, use the given default * type. If the qdev property info should not be shown, return NULL. * * The caller must free the return value. */ static ObjectPropertyInfo *make_device_property_info(ObjectClass *klass, const char *name, const char *default_type, const char *description) { ObjectPropertyInfo *info; Property *prop; do { for (prop = DEVICE_CLASS(klass)->props; prop && prop->name; prop++) { if (strcmp(name, prop->name) != 0) { continue; } /* * TODO Properties without a parser are just for dirty hacks. * qdev_prop_ptr is the only such PropertyInfo. It's marked * for removal. This conditional should be removed along with * it. */ if (!prop->info->set && !prop->info->create) { return NULL; /* no way to set it, don't show */ } info = g_malloc0(sizeof(*info)); info->name = g_strdup(prop->name); info->type = default_type ? g_strdup(default_type) : g_strdup(prop->info->name); info->has_description = !!prop->info->description; info->description = g_strdup(prop->info->description); return info; } klass = object_class_get_parent(klass); } while (klass != object_class_by_name(TYPE_DEVICE)); /* Not a qdev property, use the default type */ info = g_malloc0(sizeof(*info)); info->name = g_strdup(name); info->type = g_strdup(default_type); info->has_description = !!description; info->description = g_strdup(description); return info; }
static ObjectClass *alpha_cpu_class_by_name(const char *cpu_model) { ObjectClass *oc; char *typename; int i; oc = object_class_by_name(cpu_model); if (oc != NULL && object_class_dynamic_cast(oc, TYPE_ALPHA_CPU) != NULL && !object_class_is_abstract(oc)) { return oc; } for (i = 0; i < ARRAY_SIZE(alpha_cpu_aliases); i++) { if (strcmp(cpu_model, alpha_cpu_aliases[i].alias) == 0) { oc = object_class_by_name(alpha_cpu_aliases[i].typename); assert(oc != NULL && !object_class_is_abstract(oc)); return oc; } }
CPUUniCore32State *uc32_cpu_init(const char *cpu_model) { UniCore32CPU *cpu; CPUUniCore32State *env; static int inited = 1; if (object_class_by_name(cpu_model) == NULL) { return NULL; } cpu = UNICORE32_CPU(object_new(cpu_model)); env = &cpu->env; if (inited) { inited = 0; uc32_translate_init(); } qemu_init_vcpu(env); return env; }
DeviceState *qdev_try_create(BusState *bus, const char *type) { #if 0 DeviceState *dev; if (object_class_by_name(NULL, type) == NULL) { // no need to fix. aq return NULL; } dev = DEVICE(object_new(NULL, type)); // no need to fix. aq if (!dev) { return NULL; } if (!bus) { bus = sysbus_get_default(); } qdev_set_parent_bus(dev, bus); object_unref(OBJECT(dev)); return dev; #endif return NULL; }
Object *user_creatable_add_type(const char *type, const char *id, const QDict *qdict, Visitor *v, Error **errp) { Object *obj; ObjectClass *klass; const QDictEntry *e; Error *local_err = NULL; klass = object_class_by_name(type); if (!klass) { error_setg(errp, "invalid object type: %s", type); return NULL; } if (!object_class_dynamic_cast(klass, TYPE_USER_CREATABLE)) { error_setg(errp, "object type '%s' isn't supported by object-add", type); return NULL; } if (object_class_is_abstract(klass)) { error_setg(errp, "object type '%s' is abstract", type); return NULL; } assert(qdict); obj = object_new(type); visit_start_struct(v, NULL, NULL, 0, &local_err); if (local_err) { goto out; } for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { object_property_set(obj, v, e->key, &local_err); if (local_err) { break; } } if (!local_err) { visit_check_struct(v, &local_err); } visit_end_struct(v, NULL); if (local_err) { goto out; } if (id != NULL) { object_property_add_child(object_get_objects_root(), id, obj, &local_err); if (local_err) { goto out; } } user_creatable_complete(USER_CREATABLE(obj), &local_err); if (local_err) { if (id != NULL) { object_property_del(object_get_objects_root(), id, &error_abort); } goto out; } out: if (local_err) { error_propagate(errp, local_err); object_unref(obj); return NULL; } return obj; }
static ObjectClass *nios2_cpu_class_by_name(const char *cpu_model) { return object_class_by_name(TYPE_NIOS2_CPU); }
static ObjectClass *mb_cpu_class_by_name(const char *cpu_model) { return object_class_by_name(TYPE_MICROBLAZE_CPU); }