hw/arm/virt: Merge VirtBoardInfo and VirtMachineState
[qemu.git] / target / s390x / cpu_models.c
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"
15 #include "gen-features.h"
16 #include "qapi/error.h"
17 #include "qapi/visitor.h"
18 #include "qemu/error-report.h"
19 #include "qapi/qmp/qerror.h"
20 #include "qapi/qobject-input-visitor.h"
21 #include "qapi/qmp/qbool.h"
22 #ifndef CONFIG_USER_ONLY
23 #include "sysemu/arch_init.h"
24 #endif
25
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
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
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
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
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
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 }
161 if (feat == S390_FEAT_MSA_EXT_3) {
162 return true;
163 }
164 }
165 #endif
166 return 0;
167 }
168 return test_bit(feat, cpu->model->features);
169 }
170
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
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 };
257 S390FeatGroup group;
258 S390Feat feat;
259
260 object_class_foreach(print_cpu_model_list, TYPE_S390_CPU, false, &info);
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 }
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 }
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) {
348 visitor = qobject_input_visitor_new(info->props, true);
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 }
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 }
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 }
592 #endif
593
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()) {
671 kvm_s390_get_host_cpu_model(&max_model, errp);
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()) {
704 kvm_s390_apply_cpu_model(model, errp);
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
718 void s390_realize_cpu_model(CPUState *cs, Error **errp)
719 {
720 S390CPUClass *xcc = S390_CPU_GET_CLASS(cs);
721 S390CPU *cpu = S390_CPU(cs);
722 const S390CPUModel *max_model;
723
724 if (xcc->kvm_required && !kvm_enabled()) {
725 error_setg(errp, "CPU definition requires KVM");
726 return;
727 }
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);
753 }
754
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
887 static void s390_cpu_model_initfn(Object *obj)
888 {
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 }
904 }
905
906 #ifdef CONFIG_KVM
907 static void s390_host_cpu_model_initfn(Object *obj)
908 {
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 }
924 }
925 #endif
926
927 static void s390_qemu_cpu_model_initfn(Object *obj)
928 {
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);
936 }
937
938 static void s390_cpu_model_finalize(Object *obj)
939 {
940 S390CPU *cpu = S390_CPU(obj);
941
942 g_free(cpu->model);
943 cpu->model = NULL;
944 }
945
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
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
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
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
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
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 {
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
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)