]>
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; | |
8ed877b7 | 293 | info->q_typename = g_strdup(object_class_get_name(klass)); |
41868f84 DH |
294 | |
295 | ||
296 | entry = g_malloc0(sizeof(*entry)); | |
297 | entry->value = info; | |
298 | entry->next = *cpu_list; | |
299 | *cpu_list = entry; | |
300 | } | |
301 | ||
302 | CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp) | |
303 | { | |
304 | CpuDefinitionInfoList *list = NULL; | |
305 | ||
306 | object_class_foreach(create_cpu_model_list, TYPE_S390_CPU, false, &list); | |
307 | ||
308 | return list; | |
309 | } | |
137974ce DH |
310 | |
311 | static void cpu_model_from_info(S390CPUModel *model, const CpuModelInfo *info, | |
312 | Error **errp) | |
313 | { | |
314 | const QDict *qdict = NULL; | |
315 | const QDictEntry *e; | |
316 | Visitor *visitor; | |
317 | ObjectClass *oc; | |
318 | S390CPU *cpu; | |
319 | Object *obj; | |
320 | ||
321 | if (info->props) { | |
322 | qdict = qobject_to_qdict(info->props); | |
323 | if (!qdict) { | |
324 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict"); | |
325 | return; | |
326 | } | |
327 | } | |
328 | ||
329 | oc = cpu_class_by_name(TYPE_S390_CPU, info->name); | |
330 | if (!oc) { | |
331 | error_setg(errp, "The CPU definition \'%s\' is unknown.", info->name); | |
332 | return; | |
333 | } | |
334 | if (S390_CPU_CLASS(oc)->kvm_required && !kvm_enabled()) { | |
335 | error_setg(errp, "The CPU definition '%s' requires KVM", info->name); | |
336 | return; | |
337 | } | |
338 | obj = object_new(object_class_get_name(oc)); | |
339 | cpu = S390_CPU(obj); | |
340 | ||
341 | if (!cpu->model) { | |
342 | error_setg(errp, "Details about the host CPU model are not available, " | |
343 | "it cannot be used."); | |
344 | object_unref(obj); | |
345 | return; | |
346 | } | |
347 | ||
348 | if (qdict) { | |
048abb7b | 349 | visitor = qobject_input_visitor_new(info->props); |
137974ce DH |
350 | visit_start_struct(visitor, NULL, NULL, 0, errp); |
351 | if (*errp) { | |
352 | object_unref(obj); | |
353 | return; | |
354 | } | |
355 | for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { | |
356 | object_property_set(obj, visitor, e->key, errp); | |
357 | if (*errp) { | |
358 | break; | |
359 | } | |
360 | } | |
361 | if (!*errp) { | |
362 | visit_check_struct(visitor, errp); | |
363 | } | |
364 | visit_end_struct(visitor, NULL); | |
365 | visit_free(visitor); | |
366 | if (*errp) { | |
367 | object_unref(obj); | |
368 | return; | |
369 | } | |
370 | } | |
371 | ||
372 | /* copy the model and throw the cpu away */ | |
373 | memcpy(model, cpu->model, sizeof(*model)); | |
374 | object_unref(obj); | |
375 | } | |
376 | ||
377 | static void qdict_add_disabled_feat(const char *name, void *opaque) | |
378 | { | |
46f5ac20 | 379 | qdict_put_bool(opaque, name, false); |
137974ce DH |
380 | } |
381 | ||
382 | static void qdict_add_enabled_feat(const char *name, void *opaque) | |
383 | { | |
46f5ac20 | 384 | qdict_put_bool(opaque, name, true); |
137974ce DH |
385 | } |
386 | ||
387 | /* convert S390CPUDef into a static CpuModelInfo */ | |
388 | static void cpu_info_from_model(CpuModelInfo *info, const S390CPUModel *model, | |
389 | bool delta_changes) | |
390 | { | |
391 | QDict *qdict = qdict_new(); | |
392 | S390FeatBitmap bitmap; | |
393 | ||
394 | /* always fallback to the static base model */ | |
395 | info->name = g_strdup_printf("%s-base", model->def->name); | |
396 | ||
397 | if (delta_changes) { | |
398 | /* features deleted from the base feature set */ | |
399 | bitmap_andnot(bitmap, model->def->base_feat, model->features, | |
400 | S390_FEAT_MAX); | |
401 | if (!bitmap_empty(bitmap, S390_FEAT_MAX)) { | |
402 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat); | |
403 | } | |
404 | ||
405 | /* features added to the base feature set */ | |
406 | bitmap_andnot(bitmap, model->features, model->def->base_feat, | |
407 | S390_FEAT_MAX); | |
408 | if (!bitmap_empty(bitmap, S390_FEAT_MAX)) { | |
409 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_enabled_feat); | |
410 | } | |
411 | } else { | |
412 | /* expand all features */ | |
413 | s390_feat_bitmap_to_ascii(model->features, qdict, | |
414 | qdict_add_enabled_feat); | |
415 | bitmap_complement(bitmap, model->features, S390_FEAT_MAX); | |
416 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat); | |
417 | } | |
418 | ||
419 | if (!qdict_size(qdict)) { | |
420 | QDECREF(qdict); | |
421 | } else { | |
422 | info->props = QOBJECT(qdict); | |
423 | info->has_props = true; | |
424 | } | |
425 | } | |
426 | ||
427 | CpuModelExpansionInfo *arch_query_cpu_model_expansion(CpuModelExpansionType type, | |
428 | CpuModelInfo *model, | |
429 | Error **errp) | |
430 | { | |
431 | CpuModelExpansionInfo *expansion_info = NULL; | |
432 | S390CPUModel s390_model; | |
433 | bool delta_changes = false; | |
434 | ||
435 | /* convert it to our internal representation */ | |
436 | cpu_model_from_info(&s390_model, model, errp); | |
437 | if (*errp) { | |
438 | return NULL; | |
439 | } | |
440 | ||
441 | if (type == CPU_MODEL_EXPANSION_TYPE_STATIC) { | |
442 | delta_changes = true; | |
443 | } else if (type != CPU_MODEL_EXPANSION_TYPE_FULL) { | |
444 | error_setg(errp, "The requested expansion type is not supported."); | |
445 | return NULL; | |
446 | } | |
447 | ||
448 | /* convert it back to a static representation */ | |
449 | expansion_info = g_malloc0(sizeof(*expansion_info)); | |
450 | expansion_info->model = g_malloc0(sizeof(*expansion_info->model)); | |
451 | cpu_info_from_model(expansion_info->model, &s390_model, delta_changes); | |
452 | return expansion_info; | |
453 | } | |
4e82ef05 DH |
454 | |
455 | static void list_add_feat(const char *name, void *opaque) | |
456 | { | |
457 | strList **last = (strList **) opaque; | |
458 | strList *entry; | |
459 | ||
460 | entry = g_malloc0(sizeof(*entry)); | |
461 | entry->value = g_strdup(name); | |
462 | entry->next = *last; | |
463 | *last = entry; | |
464 | } | |
465 | ||
466 | CpuModelCompareInfo *arch_query_cpu_model_comparison(CpuModelInfo *infoa, | |
467 | CpuModelInfo *infob, | |
468 | Error **errp) | |
469 | { | |
470 | CpuModelCompareResult feat_result, gen_result; | |
471 | CpuModelCompareInfo *compare_info; | |
472 | S390FeatBitmap missing, added; | |
473 | S390CPUModel modela, modelb; | |
474 | ||
475 | /* convert both models to our internal representation */ | |
476 | cpu_model_from_info(&modela, infoa, errp); | |
477 | if (*errp) { | |
478 | return NULL; | |
479 | } | |
480 | cpu_model_from_info(&modelb, infob, errp); | |
481 | if (*errp) { | |
482 | return NULL; | |
483 | } | |
484 | compare_info = g_malloc0(sizeof(*compare_info)); | |
485 | ||
486 | /* check the cpu generation and ga level */ | |
487 | if (modela.def->gen == modelb.def->gen) { | |
488 | if (modela.def->ec_ga == modelb.def->ec_ga) { | |
489 | /* ec and corresponding bc are identical */ | |
490 | gen_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL; | |
491 | } else if (modela.def->ec_ga < modelb.def->ec_ga) { | |
492 | gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
493 | } else { | |
494 | gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
495 | } | |
496 | } else if (modela.def->gen < modelb.def->gen) { | |
497 | gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
498 | } else { | |
499 | gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
500 | } | |
501 | if (gen_result != CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
502 | /* both models cannot be made identical */ | |
503 | list_add_feat("type", &compare_info->responsible_properties); | |
504 | } | |
505 | ||
506 | /* check the feature set */ | |
507 | if (bitmap_equal(modela.features, modelb.features, S390_FEAT_MAX)) { | |
508 | feat_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL; | |
509 | } else { | |
510 | bitmap_andnot(missing, modela.features, modelb.features, S390_FEAT_MAX); | |
511 | s390_feat_bitmap_to_ascii(missing, | |
512 | &compare_info->responsible_properties, | |
513 | list_add_feat); | |
514 | bitmap_andnot(added, modelb.features, modela.features, S390_FEAT_MAX); | |
515 | s390_feat_bitmap_to_ascii(added, &compare_info->responsible_properties, | |
516 | list_add_feat); | |
517 | if (bitmap_empty(missing, S390_FEAT_MAX)) { | |
518 | feat_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
519 | } else if (bitmap_empty(added, S390_FEAT_MAX)) { | |
520 | feat_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
521 | } else { | |
522 | feat_result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE; | |
523 | } | |
524 | } | |
525 | ||
526 | /* combine the results */ | |
527 | if (gen_result == feat_result) { | |
528 | compare_info->result = gen_result; | |
529 | } else if (feat_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
530 | compare_info->result = gen_result; | |
531 | } else if (gen_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
532 | compare_info->result = feat_result; | |
533 | } else { | |
534 | compare_info->result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE; | |
535 | } | |
536 | return compare_info; | |
537 | } | |
f1a47d08 DH |
538 | |
539 | CpuModelBaselineInfo *arch_query_cpu_model_baseline(CpuModelInfo *infoa, | |
540 | CpuModelInfo *infob, | |
541 | Error **errp) | |
542 | { | |
543 | CpuModelBaselineInfo *baseline_info; | |
544 | S390CPUModel modela, modelb, model; | |
545 | uint16_t cpu_type; | |
546 | uint8_t max_gen_ga; | |
547 | uint8_t max_gen; | |
548 | ||
549 | /* convert both models to our internal representation */ | |
550 | cpu_model_from_info(&modela, infoa, errp); | |
551 | if (*errp) { | |
552 | return NULL; | |
553 | } | |
554 | ||
555 | cpu_model_from_info(&modelb, infob, errp); | |
556 | if (*errp) { | |
557 | return NULL; | |
558 | } | |
559 | ||
560 | /* features both models support */ | |
561 | bitmap_and(model.features, modela.features, modelb.features, S390_FEAT_MAX); | |
562 | ||
563 | /* detect the maximum model not regarding features */ | |
564 | if (modela.def->gen == modelb.def->gen) { | |
565 | if (modela.def->type == modelb.def->type) { | |
566 | cpu_type = modela.def->type; | |
567 | } else { | |
568 | cpu_type = 0; | |
569 | } | |
570 | max_gen = modela.def->gen; | |
571 | max_gen_ga = MIN(modela.def->ec_ga, modelb.def->ec_ga); | |
572 | } else if (modela.def->gen > modelb.def->gen) { | |
573 | cpu_type = modelb.def->type; | |
574 | max_gen = modelb.def->gen; | |
575 | max_gen_ga = modelb.def->ec_ga; | |
576 | } else { | |
577 | cpu_type = modela.def->type; | |
578 | max_gen = modela.def->gen; | |
579 | max_gen_ga = modela.def->ec_ga; | |
580 | } | |
581 | ||
582 | model.def = s390_find_cpu_def(cpu_type, max_gen, max_gen_ga, | |
583 | model.features); | |
584 | /* strip off features not part of the max model */ | |
585 | bitmap_and(model.features, model.features, model.def->full_feat, | |
586 | S390_FEAT_MAX); | |
587 | ||
588 | baseline_info = g_malloc0(sizeof(*baseline_info)); | |
589 | baseline_info->model = g_malloc0(sizeof(*baseline_info->model)); | |
590 | cpu_info_from_model(baseline_info->model, &model, true); | |
591 | return baseline_info; | |
592 | } | |
41868f84 DH |
593 | #endif |
594 | ||
80560137 DH |
595 | static void check_consistency(const S390CPUModel *model) |
596 | { | |
597 | static int dep[][2] = { | |
598 | { S390_FEAT_IPTE_RANGE, S390_FEAT_DAT_ENH }, | |
599 | { S390_FEAT_IDTE_SEGMENT, S390_FEAT_DAT_ENH }, | |
600 | { S390_FEAT_IDTE_REGION, S390_FEAT_DAT_ENH }, | |
601 | { S390_FEAT_IDTE_REGION, S390_FEAT_IDTE_SEGMENT }, | |
602 | { S390_FEAT_LOCAL_TLB_CLEARING, S390_FEAT_DAT_ENH}, | |
603 | { S390_FEAT_LONG_DISPLACEMENT_FAST, S390_FEAT_LONG_DISPLACEMENT }, | |
604 | { S390_FEAT_DFP_FAST, S390_FEAT_DFP }, | |
605 | { S390_FEAT_TRANSACTIONAL_EXE, S390_FEAT_STFLE_49 }, | |
606 | { S390_FEAT_EDAT_2, S390_FEAT_EDAT}, | |
607 | { S390_FEAT_MSA_EXT_5, S390_FEAT_KIMD_SHA_512 }, | |
608 | { S390_FEAT_MSA_EXT_5, S390_FEAT_KLMD_SHA_512 }, | |
609 | { S390_FEAT_MSA_EXT_4, S390_FEAT_MSA_EXT_3 }, | |
610 | { S390_FEAT_SIE_CMMA, S390_FEAT_CMM }, | |
611 | { S390_FEAT_SIE_CMMA, S390_FEAT_SIE_GSLS }, | |
612 | { S390_FEAT_SIE_PFMFI, S390_FEAT_EDAT }, | |
613 | }; | |
614 | int i; | |
615 | ||
616 | for (i = 0; i < ARRAY_SIZE(dep); i++) { | |
617 | if (test_bit(dep[i][0], model->features) && | |
618 | !test_bit(dep[i][1], model->features)) { | |
619 | error_report("Warning: \'%s\' requires \'%s\'.", | |
620 | s390_feat_def(dep[i][0])->name, | |
621 | s390_feat_def(dep[i][1])->name); | |
622 | } | |
623 | } | |
624 | } | |
625 | ||
626 | static void error_prepend_missing_feat(const char *name, void *opaque) | |
627 | { | |
628 | error_prepend((Error **) opaque, "%s ", name); | |
629 | } | |
630 | ||
631 | static void check_compatibility(const S390CPUModel *max_model, | |
632 | const S390CPUModel *model, Error **errp) | |
633 | { | |
634 | S390FeatBitmap missing; | |
635 | ||
636 | if (model->def->gen > max_model->def->gen) { | |
637 | error_setg(errp, "Selected CPU generation is too new. Maximum " | |
638 | "supported model in the configuration: \'%s\'", | |
639 | max_model->def->name); | |
640 | return; | |
641 | } else if (model->def->gen == max_model->def->gen && | |
642 | model->def->ec_ga > max_model->def->ec_ga) { | |
643 | error_setg(errp, "Selected CPU GA level is too new. Maximum " | |
644 | "supported model in the configuration: \'%s\'", | |
645 | max_model->def->name); | |
646 | return; | |
647 | } | |
648 | ||
649 | /* detect the missing features to properly report them */ | |
650 | bitmap_andnot(missing, model->features, max_model->features, S390_FEAT_MAX); | |
651 | if (bitmap_empty(missing, S390_FEAT_MAX)) { | |
652 | return; | |
653 | } | |
654 | ||
655 | error_setg(errp, " "); | |
656 | s390_feat_bitmap_to_ascii(missing, errp, error_prepend_missing_feat); | |
657 | error_prepend(errp, "Some features requested in the CPU model are not " | |
658 | "available in the configuration: "); | |
659 | } | |
660 | ||
661 | static S390CPUModel *get_max_cpu_model(Error **errp) | |
662 | { | |
80560137 DH |
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 | 672 | } else { |
8dc52350 | 673 | /* TCG emulates a z900 */ |
80560137 DH |
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 | } | |
80560137 DH |
682 | return NULL; |
683 | } | |
684 | ||
685 | static inline void apply_cpu_model(const S390CPUModel *model, Error **errp) | |
686 | { | |
687 | #ifndef CONFIG_USER_ONLY | |
688 | static S390CPUModel applied_model; | |
689 | static bool applied; | |
690 | ||
691 | /* | |
692 | * We have the same model for all VCPUs. KVM can only be configured before | |
693 | * any VCPUs are defined in KVM. | |
694 | */ | |
695 | if (applied) { | |
696 | if (model && memcmp(&applied_model, model, sizeof(S390CPUModel))) { | |
697 | error_setg(errp, "Mixed CPU models are not supported on s390x."); | |
698 | } | |
699 | return; | |
700 | } | |
701 | ||
702 | if (kvm_enabled()) { | |
3b84c25c | 703 | kvm_s390_apply_cpu_model(model, errp); |
80560137 DH |
704 | } else if (model) { |
705 | /* FIXME TCG - use data for stdip/stfl */ | |
706 | } | |
707 | ||
708 | if (!*errp) { | |
709 | applied = true; | |
710 | if (model) { | |
711 | applied_model = *model; | |
712 | } | |
713 | } | |
714 | #endif | |
715 | } | |
716 | ||
41868f84 DH |
717 | void s390_realize_cpu_model(CPUState *cs, Error **errp) |
718 | { | |
719 | S390CPUClass *xcc = S390_CPU_GET_CLASS(cs); | |
80560137 DH |
720 | S390CPU *cpu = S390_CPU(cs); |
721 | const S390CPUModel *max_model; | |
41868f84 DH |
722 | |
723 | if (xcc->kvm_required && !kvm_enabled()) { | |
724 | error_setg(errp, "CPU definition requires KVM"); | |
725 | return; | |
726 | } | |
80560137 DH |
727 | |
728 | if (!cpu->model) { | |
729 | /* no host model support -> perform compatibility stuff */ | |
730 | apply_cpu_model(NULL, errp); | |
731 | return; | |
732 | } | |
733 | ||
734 | max_model = get_max_cpu_model(errp); | |
735 | if (*errp) { | |
736 | error_prepend(errp, "CPU models are not available: "); | |
737 | return; | |
738 | } | |
739 | ||
740 | /* copy over properties that can vary */ | |
741 | cpu->model->lowest_ibc = max_model->lowest_ibc; | |
742 | cpu->model->cpu_id = max_model->cpu_id; | |
743 | cpu->model->cpu_ver = max_model->cpu_ver; | |
744 | ||
745 | check_consistency(cpu->model); | |
746 | check_compatibility(max_model, cpu->model, errp); | |
747 | if (*errp) { | |
748 | return; | |
749 | } | |
750 | ||
751 | apply_cpu_model(cpu->model, errp); | |
41868f84 DH |
752 | } |
753 | ||
0754f604 DH |
754 | static void get_feature(Object *obj, Visitor *v, const char *name, |
755 | void *opaque, Error **errp) | |
756 | { | |
757 | S390Feat feat = (S390Feat) opaque; | |
758 | S390CPU *cpu = S390_CPU(obj); | |
759 | bool value; | |
760 | ||
761 | if (!cpu->model) { | |
762 | error_setg(errp, "Details about the host CPU model are not available, " | |
763 | "features cannot be queried."); | |
764 | return; | |
765 | } | |
766 | ||
767 | value = test_bit(feat, cpu->model->features); | |
768 | visit_type_bool(v, name, &value, errp); | |
769 | } | |
770 | ||
771 | static void set_feature(Object *obj, Visitor *v, const char *name, | |
772 | void *opaque, Error **errp) | |
773 | { | |
774 | S390Feat feat = (S390Feat) opaque; | |
775 | DeviceState *dev = DEVICE(obj); | |
776 | S390CPU *cpu = S390_CPU(obj); | |
777 | bool value; | |
778 | ||
779 | if (dev->realized) { | |
780 | error_setg(errp, "Attempt to set property '%s' on '%s' after " | |
781 | "it was realized", name, object_get_typename(obj)); | |
782 | return; | |
783 | } else if (!cpu->model) { | |
784 | error_setg(errp, "Details about the host CPU model are not available, " | |
785 | "features cannot be changed."); | |
786 | return; | |
787 | } | |
788 | ||
789 | visit_type_bool(v, name, &value, errp); | |
790 | if (*errp) { | |
791 | return; | |
792 | } | |
793 | if (value) { | |
794 | if (!test_bit(feat, cpu->model->def->full_feat)) { | |
795 | error_setg(errp, "Feature '%s' is not available for CPU model '%s'," | |
796 | " it was introduced with later models.", | |
797 | name, cpu->model->def->name); | |
798 | return; | |
799 | } | |
800 | set_bit(feat, cpu->model->features); | |
801 | } else { | |
802 | clear_bit(feat, cpu->model->features); | |
803 | } | |
804 | } | |
805 | ||
806 | static void get_feature_group(Object *obj, Visitor *v, const char *name, | |
807 | void *opaque, Error **errp) | |
808 | { | |
809 | S390FeatGroup group = (S390FeatGroup) opaque; | |
810 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
811 | S390CPU *cpu = S390_CPU(obj); | |
812 | S390FeatBitmap tmp; | |
813 | bool value; | |
814 | ||
815 | if (!cpu->model) { | |
816 | error_setg(errp, "Details about the host CPU model are not available, " | |
817 | "features cannot be queried."); | |
818 | return; | |
819 | } | |
820 | ||
821 | /* a group is enabled if all features are enabled */ | |
822 | bitmap_and(tmp, cpu->model->features, def->feat, S390_FEAT_MAX); | |
823 | value = bitmap_equal(tmp, def->feat, S390_FEAT_MAX); | |
824 | visit_type_bool(v, name, &value, errp); | |
825 | } | |
826 | ||
827 | static void set_feature_group(Object *obj, Visitor *v, const char *name, | |
828 | void *opaque, Error **errp) | |
829 | { | |
830 | S390FeatGroup group = (S390FeatGroup) opaque; | |
831 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
832 | DeviceState *dev = DEVICE(obj); | |
833 | S390CPU *cpu = S390_CPU(obj); | |
834 | bool value; | |
835 | ||
836 | if (dev->realized) { | |
837 | error_setg(errp, "Attempt to set property '%s' on '%s' after " | |
838 | "it was realized", name, object_get_typename(obj)); | |
839 | return; | |
840 | } else if (!cpu->model) { | |
841 | error_setg(errp, "Details about the host CPU model are not available, " | |
842 | "features cannot be changed."); | |
843 | return; | |
844 | } | |
845 | ||
846 | visit_type_bool(v, name, &value, errp); | |
847 | if (*errp) { | |
848 | return; | |
849 | } | |
850 | if (value) { | |
851 | /* groups are added in one shot, so an intersect is sufficient */ | |
852 | if (!bitmap_intersects(def->feat, cpu->model->def->full_feat, | |
853 | S390_FEAT_MAX)) { | |
854 | error_setg(errp, "Group '%s' is not available for CPU model '%s'," | |
855 | " it was introduced with later models.", | |
856 | name, cpu->model->def->name); | |
857 | return; | |
858 | } | |
859 | bitmap_or(cpu->model->features, cpu->model->features, def->feat, | |
860 | S390_FEAT_MAX); | |
861 | } else { | |
862 | bitmap_andnot(cpu->model->features, cpu->model->features, def->feat, | |
863 | S390_FEAT_MAX); | |
864 | } | |
865 | } | |
866 | ||
867 | void s390_cpu_model_register_props(Object *obj) | |
868 | { | |
869 | S390FeatGroup group; | |
870 | S390Feat feat; | |
871 | ||
872 | for (feat = 0; feat < S390_FEAT_MAX; feat++) { | |
873 | const S390FeatDef *def = s390_feat_def(feat); | |
874 | object_property_add(obj, def->name, "bool", get_feature, | |
875 | set_feature, NULL, (void *) feat, NULL); | |
876 | object_property_set_description(obj, def->name, def->desc , NULL); | |
877 | } | |
878 | for (group = 0; group < S390_FEAT_GROUP_MAX; group++) { | |
879 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
880 | object_property_add(obj, def->name, "bool", get_feature_group, | |
881 | set_feature_group, NULL, (void *) group, NULL); | |
882 | object_property_set_description(obj, def->name, def->desc , NULL); | |
883 | } | |
884 | } | |
885 | ||
6c064de1 DH |
886 | static void s390_cpu_model_initfn(Object *obj) |
887 | { | |
ad5afd07 DH |
888 | S390CPU *cpu = S390_CPU(obj); |
889 | S390CPUClass *xcc = S390_CPU_GET_CLASS(cpu); | |
890 | ||
891 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
892 | /* copy the model, so we can modify it */ | |
893 | cpu->model->def = xcc->cpu_def; | |
894 | if (xcc->is_static) { | |
895 | /* base model - features will never change */ | |
896 | bitmap_copy(cpu->model->features, cpu->model->def->base_feat, | |
897 | S390_FEAT_MAX); | |
898 | } else { | |
899 | /* latest model - features can change */ | |
900 | bitmap_copy(cpu->model->features, | |
901 | cpu->model->def->default_feat, S390_FEAT_MAX); | |
902 | } | |
6c064de1 DH |
903 | } |
904 | ||
41868f84 DH |
905 | #ifdef CONFIG_KVM |
906 | static void s390_host_cpu_model_initfn(Object *obj) | |
907 | { | |
3b84c25c DH |
908 | S390CPU *cpu = S390_CPU(obj); |
909 | Error *err = NULL; | |
910 | ||
911 | if (!kvm_enabled() || !kvm_s390_cpu_models_supported()) { | |
912 | return; | |
913 | } | |
914 | ||
915 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
916 | kvm_s390_get_host_cpu_model(cpu->model, &err); | |
917 | if (err) { | |
918 | error_report_err(err); | |
919 | g_free(cpu->model); | |
920 | /* fallback to unsupported cpu models */ | |
921 | cpu->model = NULL; | |
922 | } | |
41868f84 DH |
923 | } |
924 | #endif | |
925 | ||
926 | static void s390_qemu_cpu_model_initfn(Object *obj) | |
927 | { | |
ad5afd07 DH |
928 | S390CPU *cpu = S390_CPU(obj); |
929 | ||
930 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
931 | /* TCG emulates a z900 */ | |
932 | cpu->model->def = &s390_cpu_defs[0]; | |
933 | bitmap_copy(cpu->model->features, cpu->model->def->default_feat, | |
934 | S390_FEAT_MAX); | |
41868f84 DH |
935 | } |
936 | ||
937 | static void s390_cpu_model_finalize(Object *obj) | |
938 | { | |
ad5afd07 DH |
939 | S390CPU *cpu = S390_CPU(obj); |
940 | ||
941 | g_free(cpu->model); | |
942 | cpu->model = NULL; | |
41868f84 DH |
943 | } |
944 | ||
6efadc90 DH |
945 | static bool get_is_migration_safe(Object *obj, Error **errp) |
946 | { | |
947 | return S390_CPU_GET_CLASS(obj)->is_migration_safe; | |
948 | } | |
949 | ||
950 | static bool get_is_static(Object *obj, Error **errp) | |
951 | { | |
952 | return S390_CPU_GET_CLASS(obj)->is_static; | |
953 | } | |
954 | ||
955 | static char *get_description(Object *obj, Error **errp) | |
956 | { | |
957 | return g_strdup(S390_CPU_GET_CLASS(obj)->desc); | |
958 | } | |
959 | ||
960 | void s390_cpu_model_class_register_props(ObjectClass *oc) | |
961 | { | |
962 | object_class_property_add_bool(oc, "migration-safe", get_is_migration_safe, | |
963 | NULL, NULL); | |
964 | object_class_property_add_bool(oc, "static", get_is_static, | |
965 | NULL, NULL); | |
966 | object_class_property_add_str(oc, "description", get_description, NULL, | |
967 | NULL); | |
968 | } | |
969 | ||
41868f84 DH |
970 | #ifdef CONFIG_KVM |
971 | static void s390_host_cpu_model_class_init(ObjectClass *oc, void *data) | |
972 | { | |
973 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
974 | ||
975 | xcc->kvm_required = true; | |
976 | xcc->desc = "KVM only: All recognized features"; | |
977 | } | |
978 | #endif | |
979 | ||
6c064de1 DH |
980 | static void s390_base_cpu_model_class_init(ObjectClass *oc, void *data) |
981 | { | |
982 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
983 | ||
984 | /* all base models are migration safe */ | |
985 | xcc->cpu_def = (const S390CPUDef *) data; | |
986 | xcc->is_migration_safe = true; | |
987 | xcc->is_static = true; | |
988 | xcc->desc = xcc->cpu_def->desc; | |
989 | } | |
990 | ||
991 | static void s390_cpu_model_class_init(ObjectClass *oc, void *data) | |
992 | { | |
993 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
994 | ||
995 | /* model that can change between QEMU versions */ | |
996 | xcc->cpu_def = (const S390CPUDef *) data; | |
997 | xcc->is_migration_safe = true; | |
998 | xcc->desc = xcc->cpu_def->desc; | |
999 | } | |
1000 | ||
41868f84 DH |
1001 | static void s390_qemu_cpu_model_class_init(ObjectClass *oc, void *data) |
1002 | { | |
1003 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
1004 | ||
1005 | xcc->is_migration_safe = true; | |
1006 | xcc->desc = g_strdup_printf("QEMU Virtual CPU version %s", | |
1007 | qemu_hw_version()); | |
1008 | } | |
1009 | ||
1010 | #define S390_CPU_TYPE_SUFFIX "-" TYPE_S390_CPU | |
1011 | #define S390_CPU_TYPE_NAME(name) (name S390_CPU_TYPE_SUFFIX) | |
1012 | ||
1013 | /* Generate type name for a cpu model. Caller has to free the string. */ | |
1014 | static char *s390_cpu_type_name(const char *model_name) | |
1015 | { | |
1016 | return g_strdup_printf(S390_CPU_TYPE_NAME("%s"), model_name); | |
1017 | } | |
1018 | ||
6c064de1 DH |
1019 | /* Generate type name for a base cpu model. Caller has to free the string. */ |
1020 | static char *s390_base_cpu_type_name(const char *model_name) | |
1021 | { | |
1022 | return g_strdup_printf(S390_CPU_TYPE_NAME("%s-base"), model_name); | |
1023 | } | |
1024 | ||
41868f84 DH |
1025 | ObjectClass *s390_cpu_class_by_name(const char *name) |
1026 | { | |
1027 | char *typename = s390_cpu_type_name(name); | |
1028 | ObjectClass *oc; | |
1029 | ||
1030 | oc = object_class_by_name(typename); | |
1031 | g_free(typename); | |
1032 | return oc; | |
1033 | } | |
1034 | ||
1035 | static const TypeInfo qemu_s390_cpu_type_info = { | |
1036 | .name = S390_CPU_TYPE_NAME("qemu"), | |
1037 | .parent = TYPE_S390_CPU, | |
1038 | .instance_init = s390_qemu_cpu_model_initfn, | |
1039 | .instance_finalize = s390_cpu_model_finalize, | |
1040 | .class_init = s390_qemu_cpu_model_class_init, | |
1041 | }; | |
1042 | ||
1043 | #ifdef CONFIG_KVM | |
1044 | static const TypeInfo host_s390_cpu_type_info = { | |
1045 | .name = S390_CPU_TYPE_NAME("host"), | |
1046 | .parent = TYPE_S390_CPU, | |
1047 | .instance_init = s390_host_cpu_model_initfn, | |
1048 | .instance_finalize = s390_cpu_model_finalize, | |
1049 | .class_init = s390_host_cpu_model_class_init, | |
1050 | }; | |
1051 | #endif | |
1052 | ||
1053 | static void register_types(void) | |
1054 | { | |
6c064de1 DH |
1055 | int i; |
1056 | ||
1057 | /* init all bitmaps from gnerated data initially */ | |
1058 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
1059 | s390_init_feat_bitmap(s390_cpu_defs[i].base_init, | |
1060 | s390_cpu_defs[i].base_feat); | |
1061 | s390_init_feat_bitmap(s390_cpu_defs[i].default_init, | |
1062 | s390_cpu_defs[i].default_feat); | |
1063 | s390_init_feat_bitmap(s390_cpu_defs[i].full_init, | |
1064 | s390_cpu_defs[i].full_feat); | |
1065 | } | |
1066 | ||
1067 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
1068 | char *base_name = s390_base_cpu_type_name(s390_cpu_defs[i].name); | |
1069 | TypeInfo ti_base = { | |
1070 | .name = base_name, | |
1071 | .parent = TYPE_S390_CPU, | |
1072 | .instance_init = s390_cpu_model_initfn, | |
1073 | .instance_finalize = s390_cpu_model_finalize, | |
1074 | .class_init = s390_base_cpu_model_class_init, | |
1075 | .class_data = (void *) &s390_cpu_defs[i], | |
1076 | }; | |
1077 | char *name = s390_cpu_type_name(s390_cpu_defs[i].name); | |
1078 | TypeInfo ti = { | |
1079 | .name = name, | |
1080 | .parent = TYPE_S390_CPU, | |
1081 | .instance_init = s390_cpu_model_initfn, | |
1082 | .instance_finalize = s390_cpu_model_finalize, | |
1083 | .class_init = s390_cpu_model_class_init, | |
1084 | .class_data = (void *) &s390_cpu_defs[i], | |
1085 | }; | |
1086 | ||
1087 | type_register_static(&ti_base); | |
1088 | type_register_static(&ti); | |
1089 | g_free(base_name); | |
1090 | g_free(name); | |
1091 | } | |
1092 | ||
41868f84 DH |
1093 | type_register_static(&qemu_s390_cpu_type_info); |
1094 | #ifdef CONFIG_KVM | |
1095 | type_register_static(&host_s390_cpu_type_info); | |
1096 | #endif | |
1097 | } | |
1098 | ||
1099 | type_init(register_types) |