]>
Commit | Line | Data |
---|---|---|
41868f84 DH |
1 | /* |
2 | * CPU models for s390x | |
3 | * | |
4 | * Copyright 2016 IBM Corp. | |
5 | * | |
6 | * Author(s): David Hildenbrand <dahi@linux.vnet.ibm.com> | |
7 | * | |
8 | * This work is licensed under the terms of the GNU GPL, version 2 or (at | |
9 | * your option) any later version. See the COPYING file in the top-level | |
10 | * directory. | |
11 | */ | |
12 | ||
13 | #include "qemu/osdep.h" | |
14 | #include "cpu.h" | |
6c064de1 | 15 | #include "gen-features.h" |
41868f84 | 16 | #include "qapi/error.h" |
0754f604 | 17 | #include "qapi/visitor.h" |
80560137 | 18 | #include "qemu/error-report.h" |
137974ce | 19 | #include "qapi/qmp/qerror.h" |
b3db211f | 20 | #include "qapi/qobject-input-visitor.h" |
137974ce | 21 | #include "qapi/qmp/qbool.h" |
41868f84 DH |
22 | #ifndef CONFIG_USER_ONLY |
23 | #include "sysemu/arch_init.h" | |
24 | #endif | |
25 | ||
6c064de1 DH |
26 | #define CPUDEF_INIT(_type, _gen, _ec_ga, _mha_pow, _hmfai, _name, _desc) \ |
27 | { \ | |
28 | .name = _name, \ | |
29 | .type = _type, \ | |
30 | .gen = _gen, \ | |
31 | .ec_ga = _ec_ga, \ | |
32 | .mha_pow = _mha_pow, \ | |
33 | .hmfai = _hmfai, \ | |
34 | .desc = _desc, \ | |
35 | .base_init = { S390_FEAT_LIST_GEN ## _gen ## _GA ## _ec_ga ## _BASE }, \ | |
36 | .default_init = { S390_FEAT_LIST_GEN ## _gen ## _GA ## _ec_ga ## _DEFAULT }, \ | |
37 | .full_init = { S390_FEAT_LIST_GEN ## _gen ## _GA ## _ec_ga ## _FULL }, \ | |
38 | } | |
39 | ||
40 | /* | |
41 | * CPU definiton list in order of release. For now, base features of a | |
42 | * following release are always a subset of base features of the previous | |
43 | * release. Same is correct for the other feature sets. | |
44 | * A BC release always follows the corresponding EC release. | |
45 | */ | |
46 | static S390CPUDef s390_cpu_defs[] = { | |
47 | CPUDEF_INIT(0x2064, 7, 1, 38, 0x00000000U, "z900", "IBM zSeries 900 GA1"), | |
48 | CPUDEF_INIT(0x2064, 7, 2, 38, 0x00000000U, "z900.2", "IBM zSeries 900 GA2"), | |
49 | CPUDEF_INIT(0x2064, 7, 3, 38, 0x00000000U, "z900.3", "IBM zSeries 900 GA3"), | |
50 | CPUDEF_INIT(0x2066, 7, 3, 38, 0x00000000U, "z800", "IBM zSeries 800 GA1"), | |
51 | CPUDEF_INIT(0x2084, 8, 1, 38, 0x00000000U, "z990", "IBM zSeries 990 GA1"), | |
52 | CPUDEF_INIT(0x2084, 8, 2, 38, 0x00000000U, "z990.2", "IBM zSeries 990 GA2"), | |
53 | CPUDEF_INIT(0x2084, 8, 3, 38, 0x00000000U, "z990.3", "IBM zSeries 990 GA3"), | |
54 | CPUDEF_INIT(0x2086, 8, 3, 38, 0x00000000U, "z890", "IBM zSeries 880 GA1"), | |
55 | CPUDEF_INIT(0x2084, 8, 4, 38, 0x00000000U, "z990.4", "IBM zSeries 990 GA4"), | |
56 | CPUDEF_INIT(0x2086, 8, 4, 38, 0x00000000U, "z890.2", "IBM zSeries 880 GA2"), | |
57 | CPUDEF_INIT(0x2084, 8, 5, 38, 0x00000000U, "z990.5", "IBM zSeries 990 GA5"), | |
58 | CPUDEF_INIT(0x2086, 8, 5, 38, 0x00000000U, "z890.3", "IBM zSeries 880 GA3"), | |
59 | CPUDEF_INIT(0x2094, 9, 1, 40, 0x00000000U, "z9EC", "IBM System z9 EC GA1"), | |
60 | CPUDEF_INIT(0x2094, 9, 2, 40, 0x00000000U, "z9EC.2", "IBM System z9 EC GA2"), | |
61 | CPUDEF_INIT(0x2096, 9, 2, 40, 0x00000000U, "z9BC", "IBM System z9 BC GA1"), | |
62 | CPUDEF_INIT(0x2094, 9, 3, 40, 0x00000000U, "z9EC.3", "IBM System z9 EC GA3"), | |
63 | CPUDEF_INIT(0x2096, 9, 3, 40, 0x00000000U, "z9BC.2", "IBM System z9 BC GA2"), | |
64 | CPUDEF_INIT(0x2097, 10, 1, 43, 0x00000000U, "z10EC", "IBM System z10 EC GA1"), | |
65 | CPUDEF_INIT(0x2097, 10, 2, 43, 0x00000000U, "z10EC.2", "IBM System z10 EC GA2"), | |
66 | CPUDEF_INIT(0x2098, 10, 2, 43, 0x00000000U, "z10BC", "IBM System z10 BC GA1"), | |
67 | CPUDEF_INIT(0x2097, 10, 3, 43, 0x00000000U, "z10EC.3", "IBM System z10 EC GA3"), | |
68 | CPUDEF_INIT(0x2098, 10, 3, 43, 0x00000000U, "z10BC.2", "IBM System z10 BC GA2"), | |
69 | CPUDEF_INIT(0x2817, 11, 1, 44, 0x08000000U, "z196", "IBM zEnterprise 196 GA1"), | |
70 | CPUDEF_INIT(0x2817, 11, 2, 44, 0x08000000U, "z196.2", "IBM zEnterprise 196 GA2"), | |
71 | CPUDEF_INIT(0x2818, 11, 2, 44, 0x08000000U, "z114", "IBM zEnterprise 114 GA1"), | |
72 | CPUDEF_INIT(0x2827, 12, 1, 44, 0x08000000U, "zEC12", "IBM zEnterprise EC12 GA1"), | |
73 | CPUDEF_INIT(0x2827, 12, 2, 44, 0x08000000U, "zEC12.2", "IBM zEnterprise EC12 GA2"), | |
74 | CPUDEF_INIT(0x2828, 12, 2, 44, 0x08000000U, "zBC12", "IBM zEnterprise BC12 GA1"), | |
75 | CPUDEF_INIT(0x2964, 13, 1, 47, 0x08000000U, "z13", "IBM z13 GA1"), | |
76 | CPUDEF_INIT(0x2964, 13, 2, 47, 0x08000000U, "z13.2", "IBM z13 GA2"), | |
77 | CPUDEF_INIT(0x2965, 13, 2, 47, 0x08000000U, "z13s", "IBM z13s GA1"), | |
78 | }; | |
79 | ||
a3669307 DH |
80 | uint32_t s390_get_hmfai(void) |
81 | { | |
82 | static S390CPU *cpu; | |
83 | ||
84 | if (!cpu) { | |
85 | cpu = S390_CPU(qemu_get_cpu(0)); | |
86 | } | |
87 | ||
88 | if (!cpu || !cpu->model) { | |
89 | return 0; | |
90 | } | |
91 | return cpu->model->def->hmfai; | |
92 | } | |
93 | ||
3fad3252 DH |
94 | uint8_t s390_get_mha_pow(void) |
95 | { | |
96 | static S390CPU *cpu; | |
97 | ||
98 | if (!cpu) { | |
99 | cpu = S390_CPU(qemu_get_cpu(0)); | |
100 | } | |
101 | ||
102 | if (!cpu || !cpu->model) { | |
103 | return 0; | |
104 | } | |
105 | return cpu->model->def->mha_pow; | |
106 | } | |
107 | ||
059be520 DH |
108 | uint32_t s390_get_ibc_val(void) |
109 | { | |
110 | uint16_t unblocked_ibc, lowest_ibc; | |
111 | static S390CPU *cpu; | |
112 | ||
113 | if (!cpu) { | |
114 | cpu = S390_CPU(qemu_get_cpu(0)); | |
115 | } | |
116 | ||
117 | if (!cpu || !cpu->model) { | |
118 | return 0; | |
119 | } | |
120 | unblocked_ibc = s390_ibc_from_cpu_model(cpu->model); | |
121 | lowest_ibc = cpu->model->lowest_ibc; | |
122 | /* the lowest_ibc always has to be <= unblocked_ibc */ | |
123 | if (!lowest_ibc || lowest_ibc > unblocked_ibc) { | |
124 | return 0; | |
125 | } | |
126 | return ((uint32_t) lowest_ibc << 16) | unblocked_ibc; | |
127 | } | |
128 | ||
4dd4200e DH |
129 | void s390_get_feat_block(S390FeatType type, uint8_t *data) |
130 | { | |
131 | static S390CPU *cpu; | |
132 | ||
133 | if (!cpu) { | |
134 | cpu = S390_CPU(qemu_get_cpu(0)); | |
135 | } | |
136 | ||
137 | if (!cpu || !cpu->model) { | |
138 | return; | |
139 | } | |
140 | s390_fill_feat_block(cpu->model->features, type, data); | |
141 | } | |
142 | ||
7c72ac49 DH |
143 | bool s390_has_feat(S390Feat feat) |
144 | { | |
145 | static S390CPU *cpu; | |
146 | ||
147 | if (!cpu) { | |
148 | cpu = S390_CPU(qemu_get_cpu(0)); | |
149 | } | |
150 | ||
151 | if (!cpu || !cpu->model) { | |
152 | #ifdef CONFIG_KVM | |
153 | if (kvm_enabled()) { | |
154 | if (feat == S390_FEAT_VECTOR) { | |
155 | return kvm_check_extension(kvm_state, | |
156 | KVM_CAP_S390_VECTOR_REGISTERS); | |
157 | } | |
158 | if (feat == S390_FEAT_RUNTIME_INSTRUMENTATION) { | |
159 | return kvm_s390_get_ri(); | |
160 | } | |
c85d21c7 DH |
161 | if (feat == S390_FEAT_MSA_EXT_3) { |
162 | return true; | |
163 | } | |
7c72ac49 DH |
164 | } |
165 | #endif | |
166 | return 0; | |
167 | } | |
168 | return test_bit(feat, cpu->model->features); | |
169 | } | |
170 | ||
3b84c25c DH |
171 | uint8_t s390_get_gen_for_cpu_type(uint16_t type) |
172 | { | |
173 | int i; | |
174 | ||
175 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
176 | if (s390_cpu_defs[i].type == type) { | |
177 | return s390_cpu_defs[i].gen; | |
178 | } | |
179 | } | |
180 | return 0; | |
181 | } | |
182 | ||
183 | const S390CPUDef *s390_find_cpu_def(uint16_t type, uint8_t gen, uint8_t ec_ga, | |
184 | S390FeatBitmap features) | |
185 | { | |
186 | const S390CPUDef *last_compatible = NULL; | |
187 | int i; | |
188 | ||
189 | if (!gen) { | |
190 | ec_ga = 0; | |
191 | } | |
192 | if (!gen && type) { | |
193 | gen = s390_get_gen_for_cpu_type(type); | |
194 | } | |
195 | ||
196 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
197 | const S390CPUDef *def = &s390_cpu_defs[i]; | |
198 | S390FeatBitmap missing; | |
199 | ||
200 | /* don't even try newer generations if we know the generation */ | |
201 | if (gen) { | |
202 | if (def->gen > gen) { | |
203 | break; | |
204 | } else if (def->gen == gen && ec_ga && def->ec_ga > ec_ga) { | |
205 | break; | |
206 | } | |
207 | } | |
208 | ||
209 | if (features) { | |
210 | /* see if the model satisfies the minimum features */ | |
211 | bitmap_andnot(missing, def->base_feat, features, S390_FEAT_MAX); | |
212 | if (!bitmap_empty(missing, S390_FEAT_MAX)) { | |
213 | break; | |
214 | } | |
215 | } | |
216 | ||
217 | /* stop the search if we found the exact model */ | |
218 | if (def->type == type && def->ec_ga == ec_ga) { | |
219 | return def; | |
220 | } | |
221 | last_compatible = def; | |
222 | } | |
223 | return last_compatible; | |
224 | } | |
225 | ||
41868f84 DH |
226 | struct S390PrintCpuListInfo { |
227 | FILE *f; | |
228 | fprintf_function print; | |
229 | }; | |
230 | ||
231 | static void print_cpu_model_list(ObjectClass *klass, void *opaque) | |
232 | { | |
233 | struct S390PrintCpuListInfo *info = opaque; | |
234 | S390CPUClass *scc = S390_CPU_CLASS(klass); | |
235 | char *name = g_strdup(object_class_get_name(klass)); | |
236 | const char *details = ""; | |
237 | ||
238 | if (scc->is_static) { | |
239 | details = "(static, migration-safe)"; | |
240 | } else if (scc->is_migration_safe) { | |
241 | details = "(migration-safe)"; | |
242 | } | |
243 | ||
244 | /* strip off the -s390-cpu */ | |
245 | g_strrstr(name, "-" TYPE_S390_CPU)[0] = 0; | |
246 | (*info->print)(info->f, "s390 %-15s %-35s %s\n", name, scc->desc, | |
247 | details); | |
248 | g_free(name); | |
249 | } | |
250 | ||
251 | void s390_cpu_list(FILE *f, fprintf_function print) | |
252 | { | |
253 | struct S390PrintCpuListInfo info = { | |
254 | .f = f, | |
255 | .print = print, | |
256 | }; | |
0754f604 DH |
257 | S390FeatGroup group; |
258 | S390Feat feat; | |
41868f84 DH |
259 | |
260 | object_class_foreach(print_cpu_model_list, TYPE_S390_CPU, false, &info); | |
0754f604 DH |
261 | |
262 | (*print)(f, "\nRecognized feature flags:\n"); | |
263 | for (feat = 0; feat < S390_FEAT_MAX; feat++) { | |
264 | const S390FeatDef *def = s390_feat_def(feat); | |
265 | ||
266 | (*print)(f, "%-20s %-50s\n", def->name, def->desc); | |
267 | } | |
268 | ||
269 | (*print)(f, "\nRecognized feature groups:\n"); | |
270 | for (group = 0; group < S390_FEAT_GROUP_MAX; group++) { | |
271 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
272 | ||
273 | (*print)(f, "%-20s %-50s\n", def->name, def->desc); | |
274 | } | |
41868f84 DH |
275 | } |
276 | ||
277 | #ifndef CONFIG_USER_ONLY | |
278 | static void create_cpu_model_list(ObjectClass *klass, void *opaque) | |
279 | { | |
280 | CpuDefinitionInfoList **cpu_list = opaque; | |
281 | CpuDefinitionInfoList *entry; | |
282 | CpuDefinitionInfo *info; | |
283 | char *name = g_strdup(object_class_get_name(klass)); | |
284 | S390CPUClass *scc = S390_CPU_CLASS(klass); | |
285 | ||
286 | /* strip off the -s390-cpu */ | |
287 | g_strrstr(name, "-" TYPE_S390_CPU)[0] = 0; | |
288 | info = g_malloc0(sizeof(*info)); | |
289 | info->name = name; | |
290 | info->has_migration_safe = true; | |
291 | info->migration_safe = scc->is_migration_safe; | |
292 | info->q_static = scc->is_static; | |
293 | ||
294 | ||
295 | entry = g_malloc0(sizeof(*entry)); | |
296 | entry->value = info; | |
297 | entry->next = *cpu_list; | |
298 | *cpu_list = entry; | |
299 | } | |
300 | ||
301 | CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp) | |
302 | { | |
303 | CpuDefinitionInfoList *list = NULL; | |
304 | ||
305 | object_class_foreach(create_cpu_model_list, TYPE_S390_CPU, false, &list); | |
306 | ||
307 | return list; | |
308 | } | |
137974ce DH |
309 | |
310 | static void cpu_model_from_info(S390CPUModel *model, const CpuModelInfo *info, | |
311 | Error **errp) | |
312 | { | |
313 | const QDict *qdict = NULL; | |
314 | const QDictEntry *e; | |
315 | Visitor *visitor; | |
316 | ObjectClass *oc; | |
317 | S390CPU *cpu; | |
318 | Object *obj; | |
319 | ||
320 | if (info->props) { | |
321 | qdict = qobject_to_qdict(info->props); | |
322 | if (!qdict) { | |
323 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict"); | |
324 | return; | |
325 | } | |
326 | } | |
327 | ||
328 | oc = cpu_class_by_name(TYPE_S390_CPU, info->name); | |
329 | if (!oc) { | |
330 | error_setg(errp, "The CPU definition \'%s\' is unknown.", info->name); | |
331 | return; | |
332 | } | |
333 | if (S390_CPU_CLASS(oc)->kvm_required && !kvm_enabled()) { | |
334 | error_setg(errp, "The CPU definition '%s' requires KVM", info->name); | |
335 | return; | |
336 | } | |
337 | obj = object_new(object_class_get_name(oc)); | |
338 | cpu = S390_CPU(obj); | |
339 | ||
340 | if (!cpu->model) { | |
341 | error_setg(errp, "Details about the host CPU model are not available, " | |
342 | "it cannot be used."); | |
343 | object_unref(obj); | |
344 | return; | |
345 | } | |
346 | ||
347 | if (qdict) { | |
09e68369 | 348 | visitor = qobject_input_visitor_new(info->props, true); |
137974ce DH |
349 | visit_start_struct(visitor, NULL, NULL, 0, errp); |
350 | if (*errp) { | |
351 | object_unref(obj); | |
352 | return; | |
353 | } | |
354 | for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { | |
355 | object_property_set(obj, visitor, e->key, errp); | |
356 | if (*errp) { | |
357 | break; | |
358 | } | |
359 | } | |
360 | if (!*errp) { | |
361 | visit_check_struct(visitor, errp); | |
362 | } | |
363 | visit_end_struct(visitor, NULL); | |
364 | visit_free(visitor); | |
365 | if (*errp) { | |
366 | object_unref(obj); | |
367 | return; | |
368 | } | |
369 | } | |
370 | ||
371 | /* copy the model and throw the cpu away */ | |
372 | memcpy(model, cpu->model, sizeof(*model)); | |
373 | object_unref(obj); | |
374 | } | |
375 | ||
376 | static void qdict_add_disabled_feat(const char *name, void *opaque) | |
377 | { | |
378 | qdict_put((QDict *) opaque, name, qbool_from_bool(false)); | |
379 | } | |
380 | ||
381 | static void qdict_add_enabled_feat(const char *name, void *opaque) | |
382 | { | |
383 | qdict_put((QDict *) opaque, name, qbool_from_bool(true)); | |
384 | } | |
385 | ||
386 | /* convert S390CPUDef into a static CpuModelInfo */ | |
387 | static void cpu_info_from_model(CpuModelInfo *info, const S390CPUModel *model, | |
388 | bool delta_changes) | |
389 | { | |
390 | QDict *qdict = qdict_new(); | |
391 | S390FeatBitmap bitmap; | |
392 | ||
393 | /* always fallback to the static base model */ | |
394 | info->name = g_strdup_printf("%s-base", model->def->name); | |
395 | ||
396 | if (delta_changes) { | |
397 | /* features deleted from the base feature set */ | |
398 | bitmap_andnot(bitmap, model->def->base_feat, model->features, | |
399 | S390_FEAT_MAX); | |
400 | if (!bitmap_empty(bitmap, S390_FEAT_MAX)) { | |
401 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat); | |
402 | } | |
403 | ||
404 | /* features added to the base feature set */ | |
405 | bitmap_andnot(bitmap, model->features, model->def->base_feat, | |
406 | S390_FEAT_MAX); | |
407 | if (!bitmap_empty(bitmap, S390_FEAT_MAX)) { | |
408 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_enabled_feat); | |
409 | } | |
410 | } else { | |
411 | /* expand all features */ | |
412 | s390_feat_bitmap_to_ascii(model->features, qdict, | |
413 | qdict_add_enabled_feat); | |
414 | bitmap_complement(bitmap, model->features, S390_FEAT_MAX); | |
415 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat); | |
416 | } | |
417 | ||
418 | if (!qdict_size(qdict)) { | |
419 | QDECREF(qdict); | |
420 | } else { | |
421 | info->props = QOBJECT(qdict); | |
422 | info->has_props = true; | |
423 | } | |
424 | } | |
425 | ||
426 | CpuModelExpansionInfo *arch_query_cpu_model_expansion(CpuModelExpansionType type, | |
427 | CpuModelInfo *model, | |
428 | Error **errp) | |
429 | { | |
430 | CpuModelExpansionInfo *expansion_info = NULL; | |
431 | S390CPUModel s390_model; | |
432 | bool delta_changes = false; | |
433 | ||
434 | /* convert it to our internal representation */ | |
435 | cpu_model_from_info(&s390_model, model, errp); | |
436 | if (*errp) { | |
437 | return NULL; | |
438 | } | |
439 | ||
440 | if (type == CPU_MODEL_EXPANSION_TYPE_STATIC) { | |
441 | delta_changes = true; | |
442 | } else if (type != CPU_MODEL_EXPANSION_TYPE_FULL) { | |
443 | error_setg(errp, "The requested expansion type is not supported."); | |
444 | return NULL; | |
445 | } | |
446 | ||
447 | /* convert it back to a static representation */ | |
448 | expansion_info = g_malloc0(sizeof(*expansion_info)); | |
449 | expansion_info->model = g_malloc0(sizeof(*expansion_info->model)); | |
450 | cpu_info_from_model(expansion_info->model, &s390_model, delta_changes); | |
451 | return expansion_info; | |
452 | } | |
4e82ef05 DH |
453 | |
454 | static void list_add_feat(const char *name, void *opaque) | |
455 | { | |
456 | strList **last = (strList **) opaque; | |
457 | strList *entry; | |
458 | ||
459 | entry = g_malloc0(sizeof(*entry)); | |
460 | entry->value = g_strdup(name); | |
461 | entry->next = *last; | |
462 | *last = entry; | |
463 | } | |
464 | ||
465 | CpuModelCompareInfo *arch_query_cpu_model_comparison(CpuModelInfo *infoa, | |
466 | CpuModelInfo *infob, | |
467 | Error **errp) | |
468 | { | |
469 | CpuModelCompareResult feat_result, gen_result; | |
470 | CpuModelCompareInfo *compare_info; | |
471 | S390FeatBitmap missing, added; | |
472 | S390CPUModel modela, modelb; | |
473 | ||
474 | /* convert both models to our internal representation */ | |
475 | cpu_model_from_info(&modela, infoa, errp); | |
476 | if (*errp) { | |
477 | return NULL; | |
478 | } | |
479 | cpu_model_from_info(&modelb, infob, errp); | |
480 | if (*errp) { | |
481 | return NULL; | |
482 | } | |
483 | compare_info = g_malloc0(sizeof(*compare_info)); | |
484 | ||
485 | /* check the cpu generation and ga level */ | |
486 | if (modela.def->gen == modelb.def->gen) { | |
487 | if (modela.def->ec_ga == modelb.def->ec_ga) { | |
488 | /* ec and corresponding bc are identical */ | |
489 | gen_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL; | |
490 | } else if (modela.def->ec_ga < modelb.def->ec_ga) { | |
491 | gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
492 | } else { | |
493 | gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
494 | } | |
495 | } else if (modela.def->gen < modelb.def->gen) { | |
496 | gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
497 | } else { | |
498 | gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
499 | } | |
500 | if (gen_result != CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
501 | /* both models cannot be made identical */ | |
502 | list_add_feat("type", &compare_info->responsible_properties); | |
503 | } | |
504 | ||
505 | /* check the feature set */ | |
506 | if (bitmap_equal(modela.features, modelb.features, S390_FEAT_MAX)) { | |
507 | feat_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL; | |
508 | } else { | |
509 | bitmap_andnot(missing, modela.features, modelb.features, S390_FEAT_MAX); | |
510 | s390_feat_bitmap_to_ascii(missing, | |
511 | &compare_info->responsible_properties, | |
512 | list_add_feat); | |
513 | bitmap_andnot(added, modelb.features, modela.features, S390_FEAT_MAX); | |
514 | s390_feat_bitmap_to_ascii(added, &compare_info->responsible_properties, | |
515 | list_add_feat); | |
516 | if (bitmap_empty(missing, S390_FEAT_MAX)) { | |
517 | feat_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
518 | } else if (bitmap_empty(added, S390_FEAT_MAX)) { | |
519 | feat_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
520 | } else { | |
521 | feat_result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE; | |
522 | } | |
523 | } | |
524 | ||
525 | /* combine the results */ | |
526 | if (gen_result == feat_result) { | |
527 | compare_info->result = gen_result; | |
528 | } else if (feat_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
529 | compare_info->result = gen_result; | |
530 | } else if (gen_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
531 | compare_info->result = feat_result; | |
532 | } else { | |
533 | compare_info->result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE; | |
534 | } | |
535 | return compare_info; | |
536 | } | |
f1a47d08 DH |
537 | |
538 | CpuModelBaselineInfo *arch_query_cpu_model_baseline(CpuModelInfo *infoa, | |
539 | CpuModelInfo *infob, | |
540 | Error **errp) | |
541 | { | |
542 | CpuModelBaselineInfo *baseline_info; | |
543 | S390CPUModel modela, modelb, model; | |
544 | uint16_t cpu_type; | |
545 | uint8_t max_gen_ga; | |
546 | uint8_t max_gen; | |
547 | ||
548 | /* convert both models to our internal representation */ | |
549 | cpu_model_from_info(&modela, infoa, errp); | |
550 | if (*errp) { | |
551 | return NULL; | |
552 | } | |
553 | ||
554 | cpu_model_from_info(&modelb, infob, errp); | |
555 | if (*errp) { | |
556 | return NULL; | |
557 | } | |
558 | ||
559 | /* features both models support */ | |
560 | bitmap_and(model.features, modela.features, modelb.features, S390_FEAT_MAX); | |
561 | ||
562 | /* detect the maximum model not regarding features */ | |
563 | if (modela.def->gen == modelb.def->gen) { | |
564 | if (modela.def->type == modelb.def->type) { | |
565 | cpu_type = modela.def->type; | |
566 | } else { | |
567 | cpu_type = 0; | |
568 | } | |
569 | max_gen = modela.def->gen; | |
570 | max_gen_ga = MIN(modela.def->ec_ga, modelb.def->ec_ga); | |
571 | } else if (modela.def->gen > modelb.def->gen) { | |
572 | cpu_type = modelb.def->type; | |
573 | max_gen = modelb.def->gen; | |
574 | max_gen_ga = modelb.def->ec_ga; | |
575 | } else { | |
576 | cpu_type = modela.def->type; | |
577 | max_gen = modela.def->gen; | |
578 | max_gen_ga = modela.def->ec_ga; | |
579 | } | |
580 | ||
581 | model.def = s390_find_cpu_def(cpu_type, max_gen, max_gen_ga, | |
582 | model.features); | |
583 | /* strip off features not part of the max model */ | |
584 | bitmap_and(model.features, model.features, model.def->full_feat, | |
585 | S390_FEAT_MAX); | |
586 | ||
587 | baseline_info = g_malloc0(sizeof(*baseline_info)); | |
588 | baseline_info->model = g_malloc0(sizeof(*baseline_info->model)); | |
589 | cpu_info_from_model(baseline_info->model, &model, true); | |
590 | return baseline_info; | |
591 | } | |
41868f84 DH |
592 | #endif |
593 | ||
80560137 DH |
594 | static void check_consistency(const S390CPUModel *model) |
595 | { | |
596 | static int dep[][2] = { | |
597 | { S390_FEAT_IPTE_RANGE, S390_FEAT_DAT_ENH }, | |
598 | { S390_FEAT_IDTE_SEGMENT, S390_FEAT_DAT_ENH }, | |
599 | { S390_FEAT_IDTE_REGION, S390_FEAT_DAT_ENH }, | |
600 | { S390_FEAT_IDTE_REGION, S390_FEAT_IDTE_SEGMENT }, | |
601 | { S390_FEAT_LOCAL_TLB_CLEARING, S390_FEAT_DAT_ENH}, | |
602 | { S390_FEAT_LONG_DISPLACEMENT_FAST, S390_FEAT_LONG_DISPLACEMENT }, | |
603 | { S390_FEAT_DFP_FAST, S390_FEAT_DFP }, | |
604 | { S390_FEAT_TRANSACTIONAL_EXE, S390_FEAT_STFLE_49 }, | |
605 | { S390_FEAT_EDAT_2, S390_FEAT_EDAT}, | |
606 | { S390_FEAT_MSA_EXT_5, S390_FEAT_KIMD_SHA_512 }, | |
607 | { S390_FEAT_MSA_EXT_5, S390_FEAT_KLMD_SHA_512 }, | |
608 | { S390_FEAT_MSA_EXT_4, S390_FEAT_MSA_EXT_3 }, | |
609 | { S390_FEAT_SIE_CMMA, S390_FEAT_CMM }, | |
610 | { S390_FEAT_SIE_CMMA, S390_FEAT_SIE_GSLS }, | |
611 | { S390_FEAT_SIE_PFMFI, S390_FEAT_EDAT }, | |
612 | }; | |
613 | int i; | |
614 | ||
615 | for (i = 0; i < ARRAY_SIZE(dep); i++) { | |
616 | if (test_bit(dep[i][0], model->features) && | |
617 | !test_bit(dep[i][1], model->features)) { | |
618 | error_report("Warning: \'%s\' requires \'%s\'.", | |
619 | s390_feat_def(dep[i][0])->name, | |
620 | s390_feat_def(dep[i][1])->name); | |
621 | } | |
622 | } | |
623 | } | |
624 | ||
625 | static void error_prepend_missing_feat(const char *name, void *opaque) | |
626 | { | |
627 | error_prepend((Error **) opaque, "%s ", name); | |
628 | } | |
629 | ||
630 | static void check_compatibility(const S390CPUModel *max_model, | |
631 | const S390CPUModel *model, Error **errp) | |
632 | { | |
633 | S390FeatBitmap missing; | |
634 | ||
635 | if (model->def->gen > max_model->def->gen) { | |
636 | error_setg(errp, "Selected CPU generation is too new. Maximum " | |
637 | "supported model in the configuration: \'%s\'", | |
638 | max_model->def->name); | |
639 | return; | |
640 | } else if (model->def->gen == max_model->def->gen && | |
641 | model->def->ec_ga > max_model->def->ec_ga) { | |
642 | error_setg(errp, "Selected CPU GA level is too new. Maximum " | |
643 | "supported model in the configuration: \'%s\'", | |
644 | max_model->def->name); | |
645 | return; | |
646 | } | |
647 | ||
648 | /* detect the missing features to properly report them */ | |
649 | bitmap_andnot(missing, model->features, max_model->features, S390_FEAT_MAX); | |
650 | if (bitmap_empty(missing, S390_FEAT_MAX)) { | |
651 | return; | |
652 | } | |
653 | ||
654 | error_setg(errp, " "); | |
655 | s390_feat_bitmap_to_ascii(missing, errp, error_prepend_missing_feat); | |
656 | error_prepend(errp, "Some features requested in the CPU model are not " | |
657 | "available in the configuration: "); | |
658 | } | |
659 | ||
660 | static S390CPUModel *get_max_cpu_model(Error **errp) | |
661 | { | |
662 | #ifndef CONFIG_USER_ONLY | |
663 | static S390CPUModel max_model; | |
664 | static bool cached; | |
665 | ||
666 | if (cached) { | |
667 | return &max_model; | |
668 | } | |
669 | ||
670 | if (kvm_enabled()) { | |
3b84c25c | 671 | kvm_s390_get_host_cpu_model(&max_model, errp); |
80560137 DH |
672 | } else { |
673 | /* TCG enulates a z900 */ | |
674 | max_model.def = &s390_cpu_defs[0]; | |
675 | bitmap_copy(max_model.features, max_model.def->default_feat, | |
676 | S390_FEAT_MAX); | |
677 | } | |
678 | if (!*errp) { | |
679 | cached = true; | |
680 | return &max_model; | |
681 | } | |
682 | #endif | |
683 | return NULL; | |
684 | } | |
685 | ||
686 | static inline void apply_cpu_model(const S390CPUModel *model, Error **errp) | |
687 | { | |
688 | #ifndef CONFIG_USER_ONLY | |
689 | static S390CPUModel applied_model; | |
690 | static bool applied; | |
691 | ||
692 | /* | |
693 | * We have the same model for all VCPUs. KVM can only be configured before | |
694 | * any VCPUs are defined in KVM. | |
695 | */ | |
696 | if (applied) { | |
697 | if (model && memcmp(&applied_model, model, sizeof(S390CPUModel))) { | |
698 | error_setg(errp, "Mixed CPU models are not supported on s390x."); | |
699 | } | |
700 | return; | |
701 | } | |
702 | ||
703 | if (kvm_enabled()) { | |
3b84c25c | 704 | kvm_s390_apply_cpu_model(model, errp); |
80560137 DH |
705 | } else if (model) { |
706 | /* FIXME TCG - use data for stdip/stfl */ | |
707 | } | |
708 | ||
709 | if (!*errp) { | |
710 | applied = true; | |
711 | if (model) { | |
712 | applied_model = *model; | |
713 | } | |
714 | } | |
715 | #endif | |
716 | } | |
717 | ||
41868f84 DH |
718 | void s390_realize_cpu_model(CPUState *cs, Error **errp) |
719 | { | |
720 | S390CPUClass *xcc = S390_CPU_GET_CLASS(cs); | |
80560137 DH |
721 | S390CPU *cpu = S390_CPU(cs); |
722 | const S390CPUModel *max_model; | |
41868f84 DH |
723 | |
724 | if (xcc->kvm_required && !kvm_enabled()) { | |
725 | error_setg(errp, "CPU definition requires KVM"); | |
726 | return; | |
727 | } | |
80560137 DH |
728 | |
729 | if (!cpu->model) { | |
730 | /* no host model support -> perform compatibility stuff */ | |
731 | apply_cpu_model(NULL, errp); | |
732 | return; | |
733 | } | |
734 | ||
735 | max_model = get_max_cpu_model(errp); | |
736 | if (*errp) { | |
737 | error_prepend(errp, "CPU models are not available: "); | |
738 | return; | |
739 | } | |
740 | ||
741 | /* copy over properties that can vary */ | |
742 | cpu->model->lowest_ibc = max_model->lowest_ibc; | |
743 | cpu->model->cpu_id = max_model->cpu_id; | |
744 | cpu->model->cpu_ver = max_model->cpu_ver; | |
745 | ||
746 | check_consistency(cpu->model); | |
747 | check_compatibility(max_model, cpu->model, errp); | |
748 | if (*errp) { | |
749 | return; | |
750 | } | |
751 | ||
752 | apply_cpu_model(cpu->model, errp); | |
41868f84 DH |
753 | } |
754 | ||
0754f604 DH |
755 | static void get_feature(Object *obj, Visitor *v, const char *name, |
756 | void *opaque, Error **errp) | |
757 | { | |
758 | S390Feat feat = (S390Feat) opaque; | |
759 | S390CPU *cpu = S390_CPU(obj); | |
760 | bool value; | |
761 | ||
762 | if (!cpu->model) { | |
763 | error_setg(errp, "Details about the host CPU model are not available, " | |
764 | "features cannot be queried."); | |
765 | return; | |
766 | } | |
767 | ||
768 | value = test_bit(feat, cpu->model->features); | |
769 | visit_type_bool(v, name, &value, errp); | |
770 | } | |
771 | ||
772 | static void set_feature(Object *obj, Visitor *v, const char *name, | |
773 | void *opaque, Error **errp) | |
774 | { | |
775 | S390Feat feat = (S390Feat) opaque; | |
776 | DeviceState *dev = DEVICE(obj); | |
777 | S390CPU *cpu = S390_CPU(obj); | |
778 | bool value; | |
779 | ||
780 | if (dev->realized) { | |
781 | error_setg(errp, "Attempt to set property '%s' on '%s' after " | |
782 | "it was realized", name, object_get_typename(obj)); | |
783 | return; | |
784 | } else if (!cpu->model) { | |
785 | error_setg(errp, "Details about the host CPU model are not available, " | |
786 | "features cannot be changed."); | |
787 | return; | |
788 | } | |
789 | ||
790 | visit_type_bool(v, name, &value, errp); | |
791 | if (*errp) { | |
792 | return; | |
793 | } | |
794 | if (value) { | |
795 | if (!test_bit(feat, cpu->model->def->full_feat)) { | |
796 | error_setg(errp, "Feature '%s' is not available for CPU model '%s'," | |
797 | " it was introduced with later models.", | |
798 | name, cpu->model->def->name); | |
799 | return; | |
800 | } | |
801 | set_bit(feat, cpu->model->features); | |
802 | } else { | |
803 | clear_bit(feat, cpu->model->features); | |
804 | } | |
805 | } | |
806 | ||
807 | static void get_feature_group(Object *obj, Visitor *v, const char *name, | |
808 | void *opaque, Error **errp) | |
809 | { | |
810 | S390FeatGroup group = (S390FeatGroup) opaque; | |
811 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
812 | S390CPU *cpu = S390_CPU(obj); | |
813 | S390FeatBitmap tmp; | |
814 | bool value; | |
815 | ||
816 | if (!cpu->model) { | |
817 | error_setg(errp, "Details about the host CPU model are not available, " | |
818 | "features cannot be queried."); | |
819 | return; | |
820 | } | |
821 | ||
822 | /* a group is enabled if all features are enabled */ | |
823 | bitmap_and(tmp, cpu->model->features, def->feat, S390_FEAT_MAX); | |
824 | value = bitmap_equal(tmp, def->feat, S390_FEAT_MAX); | |
825 | visit_type_bool(v, name, &value, errp); | |
826 | } | |
827 | ||
828 | static void set_feature_group(Object *obj, Visitor *v, const char *name, | |
829 | void *opaque, Error **errp) | |
830 | { | |
831 | S390FeatGroup group = (S390FeatGroup) opaque; | |
832 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
833 | DeviceState *dev = DEVICE(obj); | |
834 | S390CPU *cpu = S390_CPU(obj); | |
835 | bool value; | |
836 | ||
837 | if (dev->realized) { | |
838 | error_setg(errp, "Attempt to set property '%s' on '%s' after " | |
839 | "it was realized", name, object_get_typename(obj)); | |
840 | return; | |
841 | } else if (!cpu->model) { | |
842 | error_setg(errp, "Details about the host CPU model are not available, " | |
843 | "features cannot be changed."); | |
844 | return; | |
845 | } | |
846 | ||
847 | visit_type_bool(v, name, &value, errp); | |
848 | if (*errp) { | |
849 | return; | |
850 | } | |
851 | if (value) { | |
852 | /* groups are added in one shot, so an intersect is sufficient */ | |
853 | if (!bitmap_intersects(def->feat, cpu->model->def->full_feat, | |
854 | S390_FEAT_MAX)) { | |
855 | error_setg(errp, "Group '%s' is not available for CPU model '%s'," | |
856 | " it was introduced with later models.", | |
857 | name, cpu->model->def->name); | |
858 | return; | |
859 | } | |
860 | bitmap_or(cpu->model->features, cpu->model->features, def->feat, | |
861 | S390_FEAT_MAX); | |
862 | } else { | |
863 | bitmap_andnot(cpu->model->features, cpu->model->features, def->feat, | |
864 | S390_FEAT_MAX); | |
865 | } | |
866 | } | |
867 | ||
868 | void s390_cpu_model_register_props(Object *obj) | |
869 | { | |
870 | S390FeatGroup group; | |
871 | S390Feat feat; | |
872 | ||
873 | for (feat = 0; feat < S390_FEAT_MAX; feat++) { | |
874 | const S390FeatDef *def = s390_feat_def(feat); | |
875 | object_property_add(obj, def->name, "bool", get_feature, | |
876 | set_feature, NULL, (void *) feat, NULL); | |
877 | object_property_set_description(obj, def->name, def->desc , NULL); | |
878 | } | |
879 | for (group = 0; group < S390_FEAT_GROUP_MAX; group++) { | |
880 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
881 | object_property_add(obj, def->name, "bool", get_feature_group, | |
882 | set_feature_group, NULL, (void *) group, NULL); | |
883 | object_property_set_description(obj, def->name, def->desc , NULL); | |
884 | } | |
885 | } | |
886 | ||
6c064de1 DH |
887 | static void s390_cpu_model_initfn(Object *obj) |
888 | { | |
ad5afd07 DH |
889 | S390CPU *cpu = S390_CPU(obj); |
890 | S390CPUClass *xcc = S390_CPU_GET_CLASS(cpu); | |
891 | ||
892 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
893 | /* copy the model, so we can modify it */ | |
894 | cpu->model->def = xcc->cpu_def; | |
895 | if (xcc->is_static) { | |
896 | /* base model - features will never change */ | |
897 | bitmap_copy(cpu->model->features, cpu->model->def->base_feat, | |
898 | S390_FEAT_MAX); | |
899 | } else { | |
900 | /* latest model - features can change */ | |
901 | bitmap_copy(cpu->model->features, | |
902 | cpu->model->def->default_feat, S390_FEAT_MAX); | |
903 | } | |
6c064de1 DH |
904 | } |
905 | ||
41868f84 DH |
906 | #ifdef CONFIG_KVM |
907 | static void s390_host_cpu_model_initfn(Object *obj) | |
908 | { | |
3b84c25c DH |
909 | S390CPU *cpu = S390_CPU(obj); |
910 | Error *err = NULL; | |
911 | ||
912 | if (!kvm_enabled() || !kvm_s390_cpu_models_supported()) { | |
913 | return; | |
914 | } | |
915 | ||
916 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
917 | kvm_s390_get_host_cpu_model(cpu->model, &err); | |
918 | if (err) { | |
919 | error_report_err(err); | |
920 | g_free(cpu->model); | |
921 | /* fallback to unsupported cpu models */ | |
922 | cpu->model = NULL; | |
923 | } | |
41868f84 DH |
924 | } |
925 | #endif | |
926 | ||
927 | static void s390_qemu_cpu_model_initfn(Object *obj) | |
928 | { | |
ad5afd07 DH |
929 | S390CPU *cpu = S390_CPU(obj); |
930 | ||
931 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
932 | /* TCG emulates a z900 */ | |
933 | cpu->model->def = &s390_cpu_defs[0]; | |
934 | bitmap_copy(cpu->model->features, cpu->model->def->default_feat, | |
935 | S390_FEAT_MAX); | |
41868f84 DH |
936 | } |
937 | ||
938 | static void s390_cpu_model_finalize(Object *obj) | |
939 | { | |
ad5afd07 DH |
940 | S390CPU *cpu = S390_CPU(obj); |
941 | ||
942 | g_free(cpu->model); | |
943 | cpu->model = NULL; | |
41868f84 DH |
944 | } |
945 | ||
6efadc90 DH |
946 | static bool get_is_migration_safe(Object *obj, Error **errp) |
947 | { | |
948 | return S390_CPU_GET_CLASS(obj)->is_migration_safe; | |
949 | } | |
950 | ||
951 | static bool get_is_static(Object *obj, Error **errp) | |
952 | { | |
953 | return S390_CPU_GET_CLASS(obj)->is_static; | |
954 | } | |
955 | ||
956 | static char *get_description(Object *obj, Error **errp) | |
957 | { | |
958 | return g_strdup(S390_CPU_GET_CLASS(obj)->desc); | |
959 | } | |
960 | ||
961 | void s390_cpu_model_class_register_props(ObjectClass *oc) | |
962 | { | |
963 | object_class_property_add_bool(oc, "migration-safe", get_is_migration_safe, | |
964 | NULL, NULL); | |
965 | object_class_property_add_bool(oc, "static", get_is_static, | |
966 | NULL, NULL); | |
967 | object_class_property_add_str(oc, "description", get_description, NULL, | |
968 | NULL); | |
969 | } | |
970 | ||
41868f84 DH |
971 | #ifdef CONFIG_KVM |
972 | static void s390_host_cpu_model_class_init(ObjectClass *oc, void *data) | |
973 | { | |
974 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
975 | ||
976 | xcc->kvm_required = true; | |
977 | xcc->desc = "KVM only: All recognized features"; | |
978 | } | |
979 | #endif | |
980 | ||
6c064de1 DH |
981 | static void s390_base_cpu_model_class_init(ObjectClass *oc, void *data) |
982 | { | |
983 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
984 | ||
985 | /* all base models are migration safe */ | |
986 | xcc->cpu_def = (const S390CPUDef *) data; | |
987 | xcc->is_migration_safe = true; | |
988 | xcc->is_static = true; | |
989 | xcc->desc = xcc->cpu_def->desc; | |
990 | } | |
991 | ||
992 | static void s390_cpu_model_class_init(ObjectClass *oc, void *data) | |
993 | { | |
994 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
995 | ||
996 | /* model that can change between QEMU versions */ | |
997 | xcc->cpu_def = (const S390CPUDef *) data; | |
998 | xcc->is_migration_safe = true; | |
999 | xcc->desc = xcc->cpu_def->desc; | |
1000 | } | |
1001 | ||
41868f84 DH |
1002 | static void s390_qemu_cpu_model_class_init(ObjectClass *oc, void *data) |
1003 | { | |
1004 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
1005 | ||
1006 | xcc->is_migration_safe = true; | |
1007 | xcc->desc = g_strdup_printf("QEMU Virtual CPU version %s", | |
1008 | qemu_hw_version()); | |
1009 | } | |
1010 | ||
1011 | #define S390_CPU_TYPE_SUFFIX "-" TYPE_S390_CPU | |
1012 | #define S390_CPU_TYPE_NAME(name) (name S390_CPU_TYPE_SUFFIX) | |
1013 | ||
1014 | /* Generate type name for a cpu model. Caller has to free the string. */ | |
1015 | static char *s390_cpu_type_name(const char *model_name) | |
1016 | { | |
1017 | return g_strdup_printf(S390_CPU_TYPE_NAME("%s"), model_name); | |
1018 | } | |
1019 | ||
6c064de1 DH |
1020 | /* Generate type name for a base cpu model. Caller has to free the string. */ |
1021 | static char *s390_base_cpu_type_name(const char *model_name) | |
1022 | { | |
1023 | return g_strdup_printf(S390_CPU_TYPE_NAME("%s-base"), model_name); | |
1024 | } | |
1025 | ||
41868f84 DH |
1026 | ObjectClass *s390_cpu_class_by_name(const char *name) |
1027 | { | |
1028 | char *typename = s390_cpu_type_name(name); | |
1029 | ObjectClass *oc; | |
1030 | ||
1031 | oc = object_class_by_name(typename); | |
1032 | g_free(typename); | |
1033 | return oc; | |
1034 | } | |
1035 | ||
1036 | static const TypeInfo qemu_s390_cpu_type_info = { | |
1037 | .name = S390_CPU_TYPE_NAME("qemu"), | |
1038 | .parent = TYPE_S390_CPU, | |
1039 | .instance_init = s390_qemu_cpu_model_initfn, | |
1040 | .instance_finalize = s390_cpu_model_finalize, | |
1041 | .class_init = s390_qemu_cpu_model_class_init, | |
1042 | }; | |
1043 | ||
1044 | #ifdef CONFIG_KVM | |
1045 | static const TypeInfo host_s390_cpu_type_info = { | |
1046 | .name = S390_CPU_TYPE_NAME("host"), | |
1047 | .parent = TYPE_S390_CPU, | |
1048 | .instance_init = s390_host_cpu_model_initfn, | |
1049 | .instance_finalize = s390_cpu_model_finalize, | |
1050 | .class_init = s390_host_cpu_model_class_init, | |
1051 | }; | |
1052 | #endif | |
1053 | ||
1054 | static void register_types(void) | |
1055 | { | |
6c064de1 DH |
1056 | int i; |
1057 | ||
1058 | /* init all bitmaps from gnerated data initially */ | |
1059 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
1060 | s390_init_feat_bitmap(s390_cpu_defs[i].base_init, | |
1061 | s390_cpu_defs[i].base_feat); | |
1062 | s390_init_feat_bitmap(s390_cpu_defs[i].default_init, | |
1063 | s390_cpu_defs[i].default_feat); | |
1064 | s390_init_feat_bitmap(s390_cpu_defs[i].full_init, | |
1065 | s390_cpu_defs[i].full_feat); | |
1066 | } | |
1067 | ||
1068 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
1069 | char *base_name = s390_base_cpu_type_name(s390_cpu_defs[i].name); | |
1070 | TypeInfo ti_base = { | |
1071 | .name = base_name, | |
1072 | .parent = TYPE_S390_CPU, | |
1073 | .instance_init = s390_cpu_model_initfn, | |
1074 | .instance_finalize = s390_cpu_model_finalize, | |
1075 | .class_init = s390_base_cpu_model_class_init, | |
1076 | .class_data = (void *) &s390_cpu_defs[i], | |
1077 | }; | |
1078 | char *name = s390_cpu_type_name(s390_cpu_defs[i].name); | |
1079 | TypeInfo ti = { | |
1080 | .name = name, | |
1081 | .parent = TYPE_S390_CPU, | |
1082 | .instance_init = s390_cpu_model_initfn, | |
1083 | .instance_finalize = s390_cpu_model_finalize, | |
1084 | .class_init = s390_cpu_model_class_init, | |
1085 | .class_data = (void *) &s390_cpu_defs[i], | |
1086 | }; | |
1087 | ||
1088 | type_register_static(&ti_base); | |
1089 | type_register_static(&ti); | |
1090 | g_free(base_name); | |
1091 | g_free(name); | |
1092 | } | |
1093 | ||
41868f84 DH |
1094 | type_register_static(&qemu_s390_cpu_type_info); |
1095 | #ifdef CONFIG_KVM | |
1096 | type_register_static(&host_s390_cpu_type_info); | |
1097 | #endif | |
1098 | } | |
1099 | ||
1100 | type_init(register_types) |