]>
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"), | |
cc28a594 | 78 | CPUDEF_INIT(0x3906, 14, 1, 47, 0x08000000U, "z14", "IBM z14 GA1"), |
6c064de1 DH |
79 | }; |
80 | ||
c9ad8a7a JH |
81 | void s390_cpudef_featoff(uint8_t gen, uint8_t ec_ga, S390Feat feat) |
82 | { | |
83 | const S390CPUDef *def; | |
84 | ||
85 | def = s390_find_cpu_def(0, gen, ec_ga, NULL); | |
86 | clear_bit(feat, (unsigned long *)&def->default_feat); | |
87 | } | |
88 | ||
89 | void s390_cpudef_featoff_greater(uint8_t gen, uint8_t ec_ga, S390Feat feat) | |
90 | { | |
91 | int i; | |
92 | ||
93 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
94 | const S390CPUDef *def = &s390_cpu_defs[i]; | |
95 | ||
96 | if (def->gen < gen) { | |
97 | continue; | |
98 | } | |
99 | if (def->gen == gen && def->ec_ga < ec_ga) { | |
100 | continue; | |
101 | } | |
102 | ||
103 | clear_bit(feat, (unsigned long *)&def->default_feat); | |
104 | } | |
105 | } | |
106 | ||
a3669307 DH |
107 | uint32_t s390_get_hmfai(void) |
108 | { | |
109 | static S390CPU *cpu; | |
110 | ||
111 | if (!cpu) { | |
112 | cpu = S390_CPU(qemu_get_cpu(0)); | |
113 | } | |
114 | ||
115 | if (!cpu || !cpu->model) { | |
116 | return 0; | |
117 | } | |
118 | return cpu->model->def->hmfai; | |
119 | } | |
120 | ||
3fad3252 DH |
121 | uint8_t s390_get_mha_pow(void) |
122 | { | |
123 | static S390CPU *cpu; | |
124 | ||
125 | if (!cpu) { | |
126 | cpu = S390_CPU(qemu_get_cpu(0)); | |
127 | } | |
128 | ||
129 | if (!cpu || !cpu->model) { | |
130 | return 0; | |
131 | } | |
132 | return cpu->model->def->mha_pow; | |
133 | } | |
134 | ||
059be520 DH |
135 | uint32_t s390_get_ibc_val(void) |
136 | { | |
137 | uint16_t unblocked_ibc, lowest_ibc; | |
138 | static S390CPU *cpu; | |
139 | ||
140 | if (!cpu) { | |
141 | cpu = S390_CPU(qemu_get_cpu(0)); | |
142 | } | |
143 | ||
144 | if (!cpu || !cpu->model) { | |
145 | return 0; | |
146 | } | |
147 | unblocked_ibc = s390_ibc_from_cpu_model(cpu->model); | |
148 | lowest_ibc = cpu->model->lowest_ibc; | |
149 | /* the lowest_ibc always has to be <= unblocked_ibc */ | |
150 | if (!lowest_ibc || lowest_ibc > unblocked_ibc) { | |
151 | return 0; | |
152 | } | |
153 | return ((uint32_t) lowest_ibc << 16) | unblocked_ibc; | |
154 | } | |
155 | ||
4dd4200e DH |
156 | void s390_get_feat_block(S390FeatType type, uint8_t *data) |
157 | { | |
158 | static S390CPU *cpu; | |
159 | ||
160 | if (!cpu) { | |
161 | cpu = S390_CPU(qemu_get_cpu(0)); | |
162 | } | |
163 | ||
164 | if (!cpu || !cpu->model) { | |
165 | return; | |
166 | } | |
167 | s390_fill_feat_block(cpu->model->features, type, data); | |
168 | } | |
169 | ||
7c72ac49 DH |
170 | bool s390_has_feat(S390Feat feat) |
171 | { | |
172 | static S390CPU *cpu; | |
173 | ||
174 | if (!cpu) { | |
175 | cpu = S390_CPU(qemu_get_cpu(0)); | |
176 | } | |
177 | ||
178 | if (!cpu || !cpu->model) { | |
179 | #ifdef CONFIG_KVM | |
180 | if (kvm_enabled()) { | |
181 | if (feat == S390_FEAT_VECTOR) { | |
182 | return kvm_check_extension(kvm_state, | |
183 | KVM_CAP_S390_VECTOR_REGISTERS); | |
184 | } | |
185 | if (feat == S390_FEAT_RUNTIME_INSTRUMENTATION) { | |
186 | return kvm_s390_get_ri(); | |
187 | } | |
c85d21c7 DH |
188 | if (feat == S390_FEAT_MSA_EXT_3) { |
189 | return true; | |
190 | } | |
7c72ac49 DH |
191 | } |
192 | #endif | |
193 | return 0; | |
194 | } | |
195 | return test_bit(feat, cpu->model->features); | |
196 | } | |
197 | ||
3b84c25c DH |
198 | uint8_t s390_get_gen_for_cpu_type(uint16_t type) |
199 | { | |
200 | int i; | |
201 | ||
202 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
203 | if (s390_cpu_defs[i].type == type) { | |
204 | return s390_cpu_defs[i].gen; | |
205 | } | |
206 | } | |
207 | return 0; | |
208 | } | |
209 | ||
210 | const S390CPUDef *s390_find_cpu_def(uint16_t type, uint8_t gen, uint8_t ec_ga, | |
211 | S390FeatBitmap features) | |
212 | { | |
213 | const S390CPUDef *last_compatible = NULL; | |
fbe8202e | 214 | const S390CPUDef *matching_cpu_type = NULL; |
3b84c25c DH |
215 | int i; |
216 | ||
217 | if (!gen) { | |
218 | ec_ga = 0; | |
219 | } | |
220 | if (!gen && type) { | |
221 | gen = s390_get_gen_for_cpu_type(type); | |
222 | } | |
223 | ||
224 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
225 | const S390CPUDef *def = &s390_cpu_defs[i]; | |
226 | S390FeatBitmap missing; | |
227 | ||
228 | /* don't even try newer generations if we know the generation */ | |
229 | if (gen) { | |
230 | if (def->gen > gen) { | |
231 | break; | |
232 | } else if (def->gen == gen && ec_ga && def->ec_ga > ec_ga) { | |
233 | break; | |
234 | } | |
235 | } | |
236 | ||
237 | if (features) { | |
238 | /* see if the model satisfies the minimum features */ | |
239 | bitmap_andnot(missing, def->base_feat, features, S390_FEAT_MAX); | |
240 | if (!bitmap_empty(missing, S390_FEAT_MAX)) { | |
241 | break; | |
242 | } | |
243 | } | |
244 | ||
245 | /* stop the search if we found the exact model */ | |
246 | if (def->type == type && def->ec_ga == ec_ga) { | |
247 | return def; | |
248 | } | |
fbe8202e DH |
249 | /* remember if we've at least seen one with the same cpu type */ |
250 | if (def->type == type) { | |
251 | matching_cpu_type = def; | |
252 | } | |
3b84c25c DH |
253 | last_compatible = def; |
254 | } | |
fbe8202e DH |
255 | /* prefer the model with the same cpu type, esp. don't take the BC for EC */ |
256 | if (matching_cpu_type) { | |
257 | return matching_cpu_type; | |
258 | } | |
3b84c25c DH |
259 | return last_compatible; |
260 | } | |
261 | ||
41868f84 DH |
262 | struct S390PrintCpuListInfo { |
263 | FILE *f; | |
264 | fprintf_function print; | |
265 | }; | |
266 | ||
267 | static void print_cpu_model_list(ObjectClass *klass, void *opaque) | |
268 | { | |
269 | struct S390PrintCpuListInfo *info = opaque; | |
270 | S390CPUClass *scc = S390_CPU_CLASS(klass); | |
271 | char *name = g_strdup(object_class_get_name(klass)); | |
272 | const char *details = ""; | |
273 | ||
274 | if (scc->is_static) { | |
275 | details = "(static, migration-safe)"; | |
276 | } else if (scc->is_migration_safe) { | |
277 | details = "(migration-safe)"; | |
278 | } | |
279 | ||
280 | /* strip off the -s390-cpu */ | |
281 | g_strrstr(name, "-" TYPE_S390_CPU)[0] = 0; | |
282 | (*info->print)(info->f, "s390 %-15s %-35s %s\n", name, scc->desc, | |
283 | details); | |
284 | g_free(name); | |
285 | } | |
286 | ||
287 | void s390_cpu_list(FILE *f, fprintf_function print) | |
288 | { | |
289 | struct S390PrintCpuListInfo info = { | |
290 | .f = f, | |
291 | .print = print, | |
292 | }; | |
0754f604 DH |
293 | S390FeatGroup group; |
294 | S390Feat feat; | |
41868f84 DH |
295 | |
296 | object_class_foreach(print_cpu_model_list, TYPE_S390_CPU, false, &info); | |
0754f604 DH |
297 | |
298 | (*print)(f, "\nRecognized feature flags:\n"); | |
299 | for (feat = 0; feat < S390_FEAT_MAX; feat++) { | |
300 | const S390FeatDef *def = s390_feat_def(feat); | |
301 | ||
302 | (*print)(f, "%-20s %-50s\n", def->name, def->desc); | |
303 | } | |
304 | ||
305 | (*print)(f, "\nRecognized feature groups:\n"); | |
306 | for (group = 0; group < S390_FEAT_GROUP_MAX; group++) { | |
307 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
308 | ||
309 | (*print)(f, "%-20s %-50s\n", def->name, def->desc); | |
310 | } | |
41868f84 DH |
311 | } |
312 | ||
38cba1f4 VM |
313 | static S390CPUModel *get_max_cpu_model(Error **errp); |
314 | ||
41868f84 | 315 | #ifndef CONFIG_USER_ONLY |
38cba1f4 VM |
316 | static void list_add_feat(const char *name, void *opaque); |
317 | ||
318 | static void check_unavailable_features(const S390CPUModel *max_model, | |
319 | const S390CPUModel *model, | |
320 | strList **unavailable) | |
321 | { | |
322 | S390FeatBitmap missing; | |
323 | ||
324 | /* check general model compatibility */ | |
325 | if (max_model->def->gen < model->def->gen || | |
326 | (max_model->def->gen == model->def->gen && | |
327 | max_model->def->ec_ga < model->def->ec_ga)) { | |
328 | list_add_feat("type", unavailable); | |
329 | } | |
330 | ||
331 | /* detect missing features if any to properly report them */ | |
332 | bitmap_andnot(missing, model->features, max_model->features, | |
333 | S390_FEAT_MAX); | |
334 | if (!bitmap_empty(missing, S390_FEAT_MAX)) { | |
335 | s390_feat_bitmap_to_ascii(missing, unavailable, list_add_feat); | |
336 | } | |
337 | } | |
338 | ||
339 | struct CpuDefinitionInfoListData { | |
340 | CpuDefinitionInfoList *list; | |
341 | S390CPUModel *model; | |
342 | }; | |
343 | ||
41868f84 DH |
344 | static void create_cpu_model_list(ObjectClass *klass, void *opaque) |
345 | { | |
38cba1f4 VM |
346 | struct CpuDefinitionInfoListData *cpu_list_data = opaque; |
347 | CpuDefinitionInfoList **cpu_list = &cpu_list_data->list; | |
41868f84 DH |
348 | CpuDefinitionInfoList *entry; |
349 | CpuDefinitionInfo *info; | |
350 | char *name = g_strdup(object_class_get_name(klass)); | |
351 | S390CPUClass *scc = S390_CPU_CLASS(klass); | |
352 | ||
353 | /* strip off the -s390-cpu */ | |
354 | g_strrstr(name, "-" TYPE_S390_CPU)[0] = 0; | |
355 | info = g_malloc0(sizeof(*info)); | |
356 | info->name = name; | |
357 | info->has_migration_safe = true; | |
358 | info->migration_safe = scc->is_migration_safe; | |
359 | info->q_static = scc->is_static; | |
8ed877b7 | 360 | info->q_typename = g_strdup(object_class_get_name(klass)); |
38cba1f4 VM |
361 | /* check for unavailable features */ |
362 | if (cpu_list_data->model) { | |
363 | Object *obj; | |
364 | S390CPU *sc; | |
365 | obj = object_new(object_class_get_name(klass)); | |
366 | sc = S390_CPU(obj); | |
367 | if (sc->model) { | |
368 | info->has_unavailable_features = true; | |
369 | check_unavailable_features(cpu_list_data->model, sc->model, | |
370 | &info->unavailable_features); | |
371 | } | |
372 | object_unref(obj); | |
373 | } | |
41868f84 DH |
374 | |
375 | entry = g_malloc0(sizeof(*entry)); | |
376 | entry->value = info; | |
377 | entry->next = *cpu_list; | |
378 | *cpu_list = entry; | |
379 | } | |
380 | ||
381 | CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp) | |
382 | { | |
38cba1f4 VM |
383 | struct CpuDefinitionInfoListData list_data = { |
384 | .list = NULL, | |
385 | }; | |
386 | ||
387 | list_data.model = get_max_cpu_model(errp); | |
388 | if (*errp) { | |
389 | error_free(*errp); | |
390 | *errp = NULL; | |
391 | } | |
41868f84 | 392 | |
38cba1f4 VM |
393 | object_class_foreach(create_cpu_model_list, TYPE_S390_CPU, false, |
394 | &list_data); | |
41868f84 | 395 | |
38cba1f4 | 396 | return list_data.list; |
41868f84 | 397 | } |
137974ce DH |
398 | |
399 | static void cpu_model_from_info(S390CPUModel *model, const CpuModelInfo *info, | |
400 | Error **errp) | |
401 | { | |
402 | const QDict *qdict = NULL; | |
403 | const QDictEntry *e; | |
404 | Visitor *visitor; | |
405 | ObjectClass *oc; | |
406 | S390CPU *cpu; | |
407 | Object *obj; | |
408 | ||
409 | if (info->props) { | |
410 | qdict = qobject_to_qdict(info->props); | |
411 | if (!qdict) { | |
412 | error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict"); | |
413 | return; | |
414 | } | |
415 | } | |
416 | ||
417 | oc = cpu_class_by_name(TYPE_S390_CPU, info->name); | |
418 | if (!oc) { | |
419 | error_setg(errp, "The CPU definition \'%s\' is unknown.", info->name); | |
420 | return; | |
421 | } | |
422 | if (S390_CPU_CLASS(oc)->kvm_required && !kvm_enabled()) { | |
423 | error_setg(errp, "The CPU definition '%s' requires KVM", info->name); | |
424 | return; | |
425 | } | |
426 | obj = object_new(object_class_get_name(oc)); | |
427 | cpu = S390_CPU(obj); | |
428 | ||
429 | if (!cpu->model) { | |
430 | error_setg(errp, "Details about the host CPU model are not available, " | |
431 | "it cannot be used."); | |
432 | object_unref(obj); | |
433 | return; | |
434 | } | |
435 | ||
436 | if (qdict) { | |
048abb7b | 437 | visitor = qobject_input_visitor_new(info->props); |
137974ce DH |
438 | visit_start_struct(visitor, NULL, NULL, 0, errp); |
439 | if (*errp) { | |
440 | object_unref(obj); | |
441 | return; | |
442 | } | |
443 | for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { | |
444 | object_property_set(obj, visitor, e->key, errp); | |
445 | if (*errp) { | |
446 | break; | |
447 | } | |
448 | } | |
449 | if (!*errp) { | |
450 | visit_check_struct(visitor, errp); | |
451 | } | |
452 | visit_end_struct(visitor, NULL); | |
453 | visit_free(visitor); | |
454 | if (*errp) { | |
455 | object_unref(obj); | |
456 | return; | |
457 | } | |
458 | } | |
459 | ||
460 | /* copy the model and throw the cpu away */ | |
461 | memcpy(model, cpu->model, sizeof(*model)); | |
462 | object_unref(obj); | |
463 | } | |
464 | ||
465 | static void qdict_add_disabled_feat(const char *name, void *opaque) | |
466 | { | |
46f5ac20 | 467 | qdict_put_bool(opaque, name, false); |
137974ce DH |
468 | } |
469 | ||
470 | static void qdict_add_enabled_feat(const char *name, void *opaque) | |
471 | { | |
46f5ac20 | 472 | qdict_put_bool(opaque, name, true); |
137974ce DH |
473 | } |
474 | ||
475 | /* convert S390CPUDef into a static CpuModelInfo */ | |
476 | static void cpu_info_from_model(CpuModelInfo *info, const S390CPUModel *model, | |
477 | bool delta_changes) | |
478 | { | |
479 | QDict *qdict = qdict_new(); | |
480 | S390FeatBitmap bitmap; | |
481 | ||
482 | /* always fallback to the static base model */ | |
483 | info->name = g_strdup_printf("%s-base", model->def->name); | |
484 | ||
485 | if (delta_changes) { | |
486 | /* features deleted from the base feature set */ | |
487 | bitmap_andnot(bitmap, model->def->base_feat, model->features, | |
488 | S390_FEAT_MAX); | |
489 | if (!bitmap_empty(bitmap, S390_FEAT_MAX)) { | |
490 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat); | |
491 | } | |
492 | ||
493 | /* features added to the base feature set */ | |
494 | bitmap_andnot(bitmap, model->features, model->def->base_feat, | |
495 | S390_FEAT_MAX); | |
496 | if (!bitmap_empty(bitmap, S390_FEAT_MAX)) { | |
497 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_enabled_feat); | |
498 | } | |
499 | } else { | |
500 | /* expand all features */ | |
501 | s390_feat_bitmap_to_ascii(model->features, qdict, | |
502 | qdict_add_enabled_feat); | |
503 | bitmap_complement(bitmap, model->features, S390_FEAT_MAX); | |
504 | s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat); | |
505 | } | |
506 | ||
507 | if (!qdict_size(qdict)) { | |
508 | QDECREF(qdict); | |
509 | } else { | |
510 | info->props = QOBJECT(qdict); | |
511 | info->has_props = true; | |
512 | } | |
513 | } | |
514 | ||
515 | CpuModelExpansionInfo *arch_query_cpu_model_expansion(CpuModelExpansionType type, | |
516 | CpuModelInfo *model, | |
517 | Error **errp) | |
518 | { | |
519 | CpuModelExpansionInfo *expansion_info = NULL; | |
520 | S390CPUModel s390_model; | |
521 | bool delta_changes = false; | |
522 | ||
523 | /* convert it to our internal representation */ | |
524 | cpu_model_from_info(&s390_model, model, errp); | |
525 | if (*errp) { | |
526 | return NULL; | |
527 | } | |
528 | ||
529 | if (type == CPU_MODEL_EXPANSION_TYPE_STATIC) { | |
530 | delta_changes = true; | |
531 | } else if (type != CPU_MODEL_EXPANSION_TYPE_FULL) { | |
532 | error_setg(errp, "The requested expansion type is not supported."); | |
533 | return NULL; | |
534 | } | |
535 | ||
536 | /* convert it back to a static representation */ | |
537 | expansion_info = g_malloc0(sizeof(*expansion_info)); | |
538 | expansion_info->model = g_malloc0(sizeof(*expansion_info->model)); | |
539 | cpu_info_from_model(expansion_info->model, &s390_model, delta_changes); | |
540 | return expansion_info; | |
541 | } | |
4e82ef05 DH |
542 | |
543 | static void list_add_feat(const char *name, void *opaque) | |
544 | { | |
545 | strList **last = (strList **) opaque; | |
546 | strList *entry; | |
547 | ||
548 | entry = g_malloc0(sizeof(*entry)); | |
549 | entry->value = g_strdup(name); | |
550 | entry->next = *last; | |
551 | *last = entry; | |
552 | } | |
553 | ||
554 | CpuModelCompareInfo *arch_query_cpu_model_comparison(CpuModelInfo *infoa, | |
555 | CpuModelInfo *infob, | |
556 | Error **errp) | |
557 | { | |
558 | CpuModelCompareResult feat_result, gen_result; | |
559 | CpuModelCompareInfo *compare_info; | |
560 | S390FeatBitmap missing, added; | |
561 | S390CPUModel modela, modelb; | |
562 | ||
563 | /* convert both models to our internal representation */ | |
564 | cpu_model_from_info(&modela, infoa, errp); | |
565 | if (*errp) { | |
566 | return NULL; | |
567 | } | |
568 | cpu_model_from_info(&modelb, infob, errp); | |
569 | if (*errp) { | |
570 | return NULL; | |
571 | } | |
572 | compare_info = g_malloc0(sizeof(*compare_info)); | |
573 | ||
574 | /* check the cpu generation and ga level */ | |
575 | if (modela.def->gen == modelb.def->gen) { | |
576 | if (modela.def->ec_ga == modelb.def->ec_ga) { | |
577 | /* ec and corresponding bc are identical */ | |
578 | gen_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL; | |
579 | } else if (modela.def->ec_ga < modelb.def->ec_ga) { | |
580 | gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
581 | } else { | |
582 | gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
583 | } | |
584 | } else if (modela.def->gen < modelb.def->gen) { | |
585 | gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
586 | } else { | |
587 | gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
588 | } | |
589 | if (gen_result != CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
590 | /* both models cannot be made identical */ | |
591 | list_add_feat("type", &compare_info->responsible_properties); | |
592 | } | |
593 | ||
594 | /* check the feature set */ | |
595 | if (bitmap_equal(modela.features, modelb.features, S390_FEAT_MAX)) { | |
596 | feat_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL; | |
597 | } else { | |
598 | bitmap_andnot(missing, modela.features, modelb.features, S390_FEAT_MAX); | |
599 | s390_feat_bitmap_to_ascii(missing, | |
600 | &compare_info->responsible_properties, | |
601 | list_add_feat); | |
602 | bitmap_andnot(added, modelb.features, modela.features, S390_FEAT_MAX); | |
603 | s390_feat_bitmap_to_ascii(added, &compare_info->responsible_properties, | |
604 | list_add_feat); | |
605 | if (bitmap_empty(missing, S390_FEAT_MAX)) { | |
606 | feat_result = CPU_MODEL_COMPARE_RESULT_SUBSET; | |
607 | } else if (bitmap_empty(added, S390_FEAT_MAX)) { | |
608 | feat_result = CPU_MODEL_COMPARE_RESULT_SUPERSET; | |
609 | } else { | |
610 | feat_result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE; | |
611 | } | |
612 | } | |
613 | ||
614 | /* combine the results */ | |
615 | if (gen_result == feat_result) { | |
616 | compare_info->result = gen_result; | |
617 | } else if (feat_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
618 | compare_info->result = gen_result; | |
619 | } else if (gen_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) { | |
620 | compare_info->result = feat_result; | |
621 | } else { | |
622 | compare_info->result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE; | |
623 | } | |
624 | return compare_info; | |
625 | } | |
f1a47d08 DH |
626 | |
627 | CpuModelBaselineInfo *arch_query_cpu_model_baseline(CpuModelInfo *infoa, | |
628 | CpuModelInfo *infob, | |
629 | Error **errp) | |
630 | { | |
631 | CpuModelBaselineInfo *baseline_info; | |
632 | S390CPUModel modela, modelb, model; | |
633 | uint16_t cpu_type; | |
634 | uint8_t max_gen_ga; | |
635 | uint8_t max_gen; | |
636 | ||
637 | /* convert both models to our internal representation */ | |
638 | cpu_model_from_info(&modela, infoa, errp); | |
639 | if (*errp) { | |
640 | return NULL; | |
641 | } | |
642 | ||
643 | cpu_model_from_info(&modelb, infob, errp); | |
644 | if (*errp) { | |
645 | return NULL; | |
646 | } | |
647 | ||
648 | /* features both models support */ | |
649 | bitmap_and(model.features, modela.features, modelb.features, S390_FEAT_MAX); | |
650 | ||
651 | /* detect the maximum model not regarding features */ | |
652 | if (modela.def->gen == modelb.def->gen) { | |
653 | if (modela.def->type == modelb.def->type) { | |
654 | cpu_type = modela.def->type; | |
655 | } else { | |
656 | cpu_type = 0; | |
657 | } | |
658 | max_gen = modela.def->gen; | |
659 | max_gen_ga = MIN(modela.def->ec_ga, modelb.def->ec_ga); | |
660 | } else if (modela.def->gen > modelb.def->gen) { | |
661 | cpu_type = modelb.def->type; | |
662 | max_gen = modelb.def->gen; | |
663 | max_gen_ga = modelb.def->ec_ga; | |
664 | } else { | |
665 | cpu_type = modela.def->type; | |
666 | max_gen = modela.def->gen; | |
667 | max_gen_ga = modela.def->ec_ga; | |
668 | } | |
669 | ||
670 | model.def = s390_find_cpu_def(cpu_type, max_gen, max_gen_ga, | |
671 | model.features); | |
672 | /* strip off features not part of the max model */ | |
673 | bitmap_and(model.features, model.features, model.def->full_feat, | |
674 | S390_FEAT_MAX); | |
675 | ||
676 | baseline_info = g_malloc0(sizeof(*baseline_info)); | |
677 | baseline_info->model = g_malloc0(sizeof(*baseline_info->model)); | |
678 | cpu_info_from_model(baseline_info->model, &model, true); | |
679 | return baseline_info; | |
680 | } | |
41868f84 DH |
681 | #endif |
682 | ||
80560137 DH |
683 | static void check_consistency(const S390CPUModel *model) |
684 | { | |
685 | static int dep[][2] = { | |
686 | { S390_FEAT_IPTE_RANGE, S390_FEAT_DAT_ENH }, | |
687 | { S390_FEAT_IDTE_SEGMENT, S390_FEAT_DAT_ENH }, | |
688 | { S390_FEAT_IDTE_REGION, S390_FEAT_DAT_ENH }, | |
689 | { S390_FEAT_IDTE_REGION, S390_FEAT_IDTE_SEGMENT }, | |
690 | { S390_FEAT_LOCAL_TLB_CLEARING, S390_FEAT_DAT_ENH}, | |
691 | { S390_FEAT_LONG_DISPLACEMENT_FAST, S390_FEAT_LONG_DISPLACEMENT }, | |
692 | { S390_FEAT_DFP_FAST, S390_FEAT_DFP }, | |
693 | { S390_FEAT_TRANSACTIONAL_EXE, S390_FEAT_STFLE_49 }, | |
694 | { S390_FEAT_EDAT_2, S390_FEAT_EDAT}, | |
695 | { S390_FEAT_MSA_EXT_5, S390_FEAT_KIMD_SHA_512 }, | |
696 | { S390_FEAT_MSA_EXT_5, S390_FEAT_KLMD_SHA_512 }, | |
697 | { S390_FEAT_MSA_EXT_4, S390_FEAT_MSA_EXT_3 }, | |
698 | { S390_FEAT_SIE_CMMA, S390_FEAT_CMM }, | |
699 | { S390_FEAT_SIE_CMMA, S390_FEAT_SIE_GSLS }, | |
700 | { S390_FEAT_SIE_PFMFI, S390_FEAT_EDAT }, | |
6da5c593 JH |
701 | { S390_FEAT_MSA_EXT_8, S390_FEAT_MSA_EXT_3 }, |
702 | { S390_FEAT_MULTIPLE_EPOCH, S390_FEAT_TOD_CLOCK_STEERING }, | |
703 | { S390_FEAT_VECTOR_PACKED_DECIMAL, S390_FEAT_VECTOR }, | |
704 | { S390_FEAT_VECTOR_ENH, S390_FEAT_VECTOR }, | |
705 | { S390_FEAT_INSTRUCTION_EXEC_PROT, S390_FEAT_SIDE_EFFECT_ACCESS_ESOP2 }, | |
706 | { S390_FEAT_SIDE_EFFECT_ACCESS_ESOP2, S390_FEAT_ESOP }, | |
707 | { S390_FEAT_CMM_NT, S390_FEAT_CMM }, | |
708 | { S390_FEAT_GUARDED_STORAGE, S390_FEAT_SIDE_EFFECT_ACCESS_ESOP2 }, | |
709 | { S390_FEAT_MULTIPLE_EPOCH, S390_FEAT_STORE_CLOCK_FAST }, | |
710 | { S390_FEAT_MULTIPLE_EPOCH, S390_FEAT_TOD_CLOCK_STEERING }, | |
711 | { S390_FEAT_SEMAPHORE_ASSIST, S390_FEAT_STFLE_49 }, | |
712 | { S390_FEAT_KIMD_SHA3_224, S390_FEAT_MSA }, | |
713 | { S390_FEAT_KIMD_SHA3_256, S390_FEAT_MSA }, | |
714 | { S390_FEAT_KIMD_SHA3_384, S390_FEAT_MSA }, | |
715 | { S390_FEAT_KIMD_SHA3_512, S390_FEAT_MSA }, | |
716 | { S390_FEAT_KIMD_SHAKE_128, S390_FEAT_MSA }, | |
717 | { S390_FEAT_KIMD_SHAKE_256, S390_FEAT_MSA }, | |
718 | { S390_FEAT_KLMD_SHA3_224, S390_FEAT_MSA }, | |
719 | { S390_FEAT_KLMD_SHA3_256, S390_FEAT_MSA }, | |
720 | { S390_FEAT_KLMD_SHA3_384, S390_FEAT_MSA }, | |
721 | { S390_FEAT_KLMD_SHA3_512, S390_FEAT_MSA }, | |
722 | { S390_FEAT_KLMD_SHAKE_128, S390_FEAT_MSA }, | |
723 | { S390_FEAT_KLMD_SHAKE_256, S390_FEAT_MSA }, | |
724 | { S390_FEAT_PRNO_TRNG_QRTCR, S390_FEAT_MSA_EXT_5 }, | |
725 | { S390_FEAT_PRNO_TRNG, S390_FEAT_MSA_EXT_5 }, | |
80560137 DH |
726 | }; |
727 | int i; | |
728 | ||
729 | for (i = 0; i < ARRAY_SIZE(dep); i++) { | |
730 | if (test_bit(dep[i][0], model->features) && | |
731 | !test_bit(dep[i][1], model->features)) { | |
3dc6f869 AF |
732 | warn_report("\'%s\' requires \'%s\'.", |
733 | s390_feat_def(dep[i][0])->name, | |
734 | s390_feat_def(dep[i][1])->name); | |
80560137 DH |
735 | } |
736 | } | |
737 | } | |
738 | ||
739 | static void error_prepend_missing_feat(const char *name, void *opaque) | |
740 | { | |
741 | error_prepend((Error **) opaque, "%s ", name); | |
742 | } | |
743 | ||
744 | static void check_compatibility(const S390CPUModel *max_model, | |
745 | const S390CPUModel *model, Error **errp) | |
746 | { | |
747 | S390FeatBitmap missing; | |
748 | ||
749 | if (model->def->gen > max_model->def->gen) { | |
750 | error_setg(errp, "Selected CPU generation is too new. Maximum " | |
751 | "supported model in the configuration: \'%s\'", | |
752 | max_model->def->name); | |
753 | return; | |
754 | } else if (model->def->gen == max_model->def->gen && | |
755 | model->def->ec_ga > max_model->def->ec_ga) { | |
756 | error_setg(errp, "Selected CPU GA level is too new. Maximum " | |
757 | "supported model in the configuration: \'%s\'", | |
758 | max_model->def->name); | |
759 | return; | |
760 | } | |
761 | ||
762 | /* detect the missing features to properly report them */ | |
763 | bitmap_andnot(missing, model->features, max_model->features, S390_FEAT_MAX); | |
764 | if (bitmap_empty(missing, S390_FEAT_MAX)) { | |
765 | return; | |
766 | } | |
767 | ||
768 | error_setg(errp, " "); | |
769 | s390_feat_bitmap_to_ascii(missing, errp, error_prepend_missing_feat); | |
770 | error_prepend(errp, "Some features requested in the CPU model are not " | |
771 | "available in the configuration: "); | |
772 | } | |
773 | ||
fc7fbcbc TH |
774 | /** |
775 | * The base TCG CPU model "qemu" is based on the z900. However, we already | |
776 | * can also emulate some additional features of later CPU generations, so | |
777 | * we add these additional feature bits here. | |
778 | */ | |
779 | static void add_qemu_cpu_model_features(S390FeatBitmap fbm) | |
780 | { | |
781 | static const int feats[] = { | |
be7f28de | 782 | S390_FEAT_DAT_ENH, |
19d70587 | 783 | S390_FEAT_IDTE_SEGMENT, |
fc7fbcbc TH |
784 | S390_FEAT_STFLE, |
785 | S390_FEAT_EXTENDED_IMMEDIATE, | |
3190dfc5 | 786 | S390_FEAT_EXTENDED_TRANSLATION_2, |
e89ea6aa | 787 | S390_FEAT_EXTENDED_TRANSLATION_3, |
fc7fbcbc TH |
788 | S390_FEAT_LONG_DISPLACEMENT, |
789 | S390_FEAT_LONG_DISPLACEMENT_FAST, | |
3190dfc5 | 790 | S390_FEAT_ETF2_ENH, |
fc7fbcbc | 791 | S390_FEAT_STORE_CLOCK_FAST, |
3e7e5e0b | 792 | S390_FEAT_MOVE_WITH_OPTIONAL_SPEC, |
e89ea6aa | 793 | S390_FEAT_ETF3_ENH, |
c67ba303 RH |
794 | S390_FEAT_COMPARE_AND_SWAP_AND_STORE, |
795 | S390_FEAT_COMPARE_AND_SWAP_AND_STORE_2, | |
fc7fbcbc TH |
796 | S390_FEAT_GENERAL_INSTRUCTIONS_EXT, |
797 | S390_FEAT_EXECUTE_EXT, | |
e1a5d922 | 798 | S390_FEAT_FLOATING_POINT_SUPPPORT_ENH, |
fc7fbcbc | 799 | S390_FEAT_STFLE_45, |
afa26f3b | 800 | S390_FEAT_STFLE_49, |
faf1c63d | 801 | S390_FEAT_LOCAL_TLB_CLEARING, |
37b8638d | 802 | S390_FEAT_STFLE_53, |
fc7fbcbc TH |
803 | }; |
804 | int i; | |
805 | ||
806 | for (i = 0; i < ARRAY_SIZE(feats); i++) { | |
807 | set_bit(feats[i], fbm); | |
808 | } | |
809 | } | |
810 | ||
80560137 DH |
811 | static S390CPUModel *get_max_cpu_model(Error **errp) |
812 | { | |
80560137 DH |
813 | static S390CPUModel max_model; |
814 | static bool cached; | |
815 | ||
816 | if (cached) { | |
817 | return &max_model; | |
818 | } | |
819 | ||
820 | if (kvm_enabled()) { | |
3b84c25c | 821 | kvm_s390_get_host_cpu_model(&max_model, errp); |
80560137 | 822 | } else { |
fc7fbcbc | 823 | /* TCG emulates a z900 (with some optional additional features) */ |
80560137 DH |
824 | max_model.def = &s390_cpu_defs[0]; |
825 | bitmap_copy(max_model.features, max_model.def->default_feat, | |
826 | S390_FEAT_MAX); | |
fc7fbcbc | 827 | add_qemu_cpu_model_features(max_model.features); |
80560137 DH |
828 | } |
829 | if (!*errp) { | |
830 | cached = true; | |
831 | return &max_model; | |
832 | } | |
80560137 DH |
833 | return NULL; |
834 | } | |
835 | ||
836 | static inline void apply_cpu_model(const S390CPUModel *model, Error **errp) | |
837 | { | |
838 | #ifndef CONFIG_USER_ONLY | |
839 | static S390CPUModel applied_model; | |
840 | static bool applied; | |
841 | ||
842 | /* | |
843 | * We have the same model for all VCPUs. KVM can only be configured before | |
844 | * any VCPUs are defined in KVM. | |
845 | */ | |
846 | if (applied) { | |
847 | if (model && memcmp(&applied_model, model, sizeof(S390CPUModel))) { | |
848 | error_setg(errp, "Mixed CPU models are not supported on s390x."); | |
849 | } | |
850 | return; | |
851 | } | |
852 | ||
853 | if (kvm_enabled()) { | |
3b84c25c | 854 | kvm_s390_apply_cpu_model(model, errp); |
80560137 DH |
855 | } |
856 | ||
857 | if (!*errp) { | |
858 | applied = true; | |
859 | if (model) { | |
860 | applied_model = *model; | |
861 | } | |
862 | } | |
863 | #endif | |
864 | } | |
865 | ||
41868f84 DH |
866 | void s390_realize_cpu_model(CPUState *cs, Error **errp) |
867 | { | |
868 | S390CPUClass *xcc = S390_CPU_GET_CLASS(cs); | |
80560137 DH |
869 | S390CPU *cpu = S390_CPU(cs); |
870 | const S390CPUModel *max_model; | |
41868f84 DH |
871 | |
872 | if (xcc->kvm_required && !kvm_enabled()) { | |
873 | error_setg(errp, "CPU definition requires KVM"); | |
874 | return; | |
875 | } | |
80560137 DH |
876 | |
877 | if (!cpu->model) { | |
878 | /* no host model support -> perform compatibility stuff */ | |
879 | apply_cpu_model(NULL, errp); | |
880 | return; | |
881 | } | |
882 | ||
883 | max_model = get_max_cpu_model(errp); | |
884 | if (*errp) { | |
885 | error_prepend(errp, "CPU models are not available: "); | |
886 | return; | |
887 | } | |
888 | ||
889 | /* copy over properties that can vary */ | |
890 | cpu->model->lowest_ibc = max_model->lowest_ibc; | |
891 | cpu->model->cpu_id = max_model->cpu_id; | |
64bc98f4 | 892 | cpu->model->cpu_id_format = max_model->cpu_id_format; |
80560137 DH |
893 | cpu->model->cpu_ver = max_model->cpu_ver; |
894 | ||
895 | check_consistency(cpu->model); | |
896 | check_compatibility(max_model, cpu->model, errp); | |
897 | if (*errp) { | |
898 | return; | |
899 | } | |
900 | ||
901 | apply_cpu_model(cpu->model, errp); | |
076d4d39 DH |
902 | |
903 | cpu->env.cpuid = s390_cpuid_from_cpu_model(cpu->model); | |
904 | if (tcg_enabled()) { | |
905 | /* basic mode, write the cpu address into the first 4 bit of the ID */ | |
906 | cpu->env.cpuid = deposit64(cpu->env.cpuid, 54, 4, cpu->env.cpu_num); | |
907 | } | |
41868f84 DH |
908 | } |
909 | ||
0754f604 DH |
910 | static void get_feature(Object *obj, Visitor *v, const char *name, |
911 | void *opaque, Error **errp) | |
912 | { | |
913 | S390Feat feat = (S390Feat) opaque; | |
914 | S390CPU *cpu = S390_CPU(obj); | |
915 | bool value; | |
916 | ||
917 | if (!cpu->model) { | |
918 | error_setg(errp, "Details about the host CPU model are not available, " | |
919 | "features cannot be queried."); | |
920 | return; | |
921 | } | |
922 | ||
923 | value = test_bit(feat, cpu->model->features); | |
924 | visit_type_bool(v, name, &value, errp); | |
925 | } | |
926 | ||
927 | static void set_feature(Object *obj, Visitor *v, const char *name, | |
928 | void *opaque, Error **errp) | |
929 | { | |
930 | S390Feat feat = (S390Feat) opaque; | |
931 | DeviceState *dev = DEVICE(obj); | |
932 | S390CPU *cpu = S390_CPU(obj); | |
933 | bool value; | |
934 | ||
935 | if (dev->realized) { | |
936 | error_setg(errp, "Attempt to set property '%s' on '%s' after " | |
937 | "it was realized", name, object_get_typename(obj)); | |
938 | return; | |
939 | } else if (!cpu->model) { | |
940 | error_setg(errp, "Details about the host CPU model are not available, " | |
941 | "features cannot be changed."); | |
942 | return; | |
943 | } | |
944 | ||
945 | visit_type_bool(v, name, &value, errp); | |
946 | if (*errp) { | |
947 | return; | |
948 | } | |
949 | if (value) { | |
950 | if (!test_bit(feat, cpu->model->def->full_feat)) { | |
951 | error_setg(errp, "Feature '%s' is not available for CPU model '%s'," | |
952 | " it was introduced with later models.", | |
953 | name, cpu->model->def->name); | |
954 | return; | |
955 | } | |
956 | set_bit(feat, cpu->model->features); | |
957 | } else { | |
958 | clear_bit(feat, cpu->model->features); | |
959 | } | |
960 | } | |
961 | ||
962 | static void get_feature_group(Object *obj, Visitor *v, const char *name, | |
963 | void *opaque, Error **errp) | |
964 | { | |
965 | S390FeatGroup group = (S390FeatGroup) opaque; | |
966 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
967 | S390CPU *cpu = S390_CPU(obj); | |
968 | S390FeatBitmap tmp; | |
969 | bool value; | |
970 | ||
971 | if (!cpu->model) { | |
972 | error_setg(errp, "Details about the host CPU model are not available, " | |
973 | "features cannot be queried."); | |
974 | return; | |
975 | } | |
976 | ||
977 | /* a group is enabled if all features are enabled */ | |
978 | bitmap_and(tmp, cpu->model->features, def->feat, S390_FEAT_MAX); | |
979 | value = bitmap_equal(tmp, def->feat, S390_FEAT_MAX); | |
980 | visit_type_bool(v, name, &value, errp); | |
981 | } | |
982 | ||
983 | static void set_feature_group(Object *obj, Visitor *v, const char *name, | |
984 | void *opaque, Error **errp) | |
985 | { | |
986 | S390FeatGroup group = (S390FeatGroup) opaque; | |
987 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
988 | DeviceState *dev = DEVICE(obj); | |
989 | S390CPU *cpu = S390_CPU(obj); | |
990 | bool value; | |
991 | ||
992 | if (dev->realized) { | |
993 | error_setg(errp, "Attempt to set property '%s' on '%s' after " | |
994 | "it was realized", name, object_get_typename(obj)); | |
995 | return; | |
996 | } else if (!cpu->model) { | |
997 | error_setg(errp, "Details about the host CPU model are not available, " | |
998 | "features cannot be changed."); | |
999 | return; | |
1000 | } | |
1001 | ||
1002 | visit_type_bool(v, name, &value, errp); | |
1003 | if (*errp) { | |
1004 | return; | |
1005 | } | |
1006 | if (value) { | |
1007 | /* groups are added in one shot, so an intersect is sufficient */ | |
1008 | if (!bitmap_intersects(def->feat, cpu->model->def->full_feat, | |
1009 | S390_FEAT_MAX)) { | |
1010 | error_setg(errp, "Group '%s' is not available for CPU model '%s'," | |
1011 | " it was introduced with later models.", | |
1012 | name, cpu->model->def->name); | |
1013 | return; | |
1014 | } | |
1015 | bitmap_or(cpu->model->features, cpu->model->features, def->feat, | |
1016 | S390_FEAT_MAX); | |
1017 | } else { | |
1018 | bitmap_andnot(cpu->model->features, cpu->model->features, def->feat, | |
1019 | S390_FEAT_MAX); | |
1020 | } | |
1021 | } | |
1022 | ||
1023 | void s390_cpu_model_register_props(Object *obj) | |
1024 | { | |
1025 | S390FeatGroup group; | |
1026 | S390Feat feat; | |
1027 | ||
1028 | for (feat = 0; feat < S390_FEAT_MAX; feat++) { | |
1029 | const S390FeatDef *def = s390_feat_def(feat); | |
1030 | object_property_add(obj, def->name, "bool", get_feature, | |
1031 | set_feature, NULL, (void *) feat, NULL); | |
1032 | object_property_set_description(obj, def->name, def->desc , NULL); | |
1033 | } | |
1034 | for (group = 0; group < S390_FEAT_GROUP_MAX; group++) { | |
1035 | const S390FeatGroupDef *def = s390_feat_group_def(group); | |
1036 | object_property_add(obj, def->name, "bool", get_feature_group, | |
1037 | set_feature_group, NULL, (void *) group, NULL); | |
1038 | object_property_set_description(obj, def->name, def->desc , NULL); | |
1039 | } | |
1040 | } | |
1041 | ||
6c064de1 DH |
1042 | static void s390_cpu_model_initfn(Object *obj) |
1043 | { | |
ad5afd07 DH |
1044 | S390CPU *cpu = S390_CPU(obj); |
1045 | S390CPUClass *xcc = S390_CPU_GET_CLASS(cpu); | |
1046 | ||
1047 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
1048 | /* copy the model, so we can modify it */ | |
1049 | cpu->model->def = xcc->cpu_def; | |
1050 | if (xcc->is_static) { | |
1051 | /* base model - features will never change */ | |
1052 | bitmap_copy(cpu->model->features, cpu->model->def->base_feat, | |
1053 | S390_FEAT_MAX); | |
1054 | } else { | |
1055 | /* latest model - features can change */ | |
1056 | bitmap_copy(cpu->model->features, | |
1057 | cpu->model->def->default_feat, S390_FEAT_MAX); | |
1058 | } | |
6c064de1 DH |
1059 | } |
1060 | ||
41868f84 DH |
1061 | #ifdef CONFIG_KVM |
1062 | static void s390_host_cpu_model_initfn(Object *obj) | |
1063 | { | |
3b84c25c DH |
1064 | S390CPU *cpu = S390_CPU(obj); |
1065 | Error *err = NULL; | |
1066 | ||
1067 | if (!kvm_enabled() || !kvm_s390_cpu_models_supported()) { | |
1068 | return; | |
1069 | } | |
1070 | ||
1071 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
1072 | kvm_s390_get_host_cpu_model(cpu->model, &err); | |
1073 | if (err) { | |
1074 | error_report_err(err); | |
1075 | g_free(cpu->model); | |
1076 | /* fallback to unsupported cpu models */ | |
1077 | cpu->model = NULL; | |
1078 | } | |
41868f84 DH |
1079 | } |
1080 | #endif | |
1081 | ||
1082 | static void s390_qemu_cpu_model_initfn(Object *obj) | |
1083 | { | |
fc7fbcbc | 1084 | static S390CPUDef s390_qemu_cpu_defs; |
ad5afd07 DH |
1085 | S390CPU *cpu = S390_CPU(obj); |
1086 | ||
1087 | cpu->model = g_malloc0(sizeof(*cpu->model)); | |
fc7fbcbc TH |
1088 | /* TCG emulates a z900 (with some optional additional features) */ |
1089 | memcpy(&s390_qemu_cpu_defs, &s390_cpu_defs[0], sizeof(s390_qemu_cpu_defs)); | |
1090 | add_qemu_cpu_model_features(s390_qemu_cpu_defs.full_feat); | |
1091 | cpu->model->def = &s390_qemu_cpu_defs; | |
ad5afd07 DH |
1092 | bitmap_copy(cpu->model->features, cpu->model->def->default_feat, |
1093 | S390_FEAT_MAX); | |
41868f84 DH |
1094 | } |
1095 | ||
1096 | static void s390_cpu_model_finalize(Object *obj) | |
1097 | { | |
ad5afd07 DH |
1098 | S390CPU *cpu = S390_CPU(obj); |
1099 | ||
1100 | g_free(cpu->model); | |
1101 | cpu->model = NULL; | |
41868f84 DH |
1102 | } |
1103 | ||
6efadc90 DH |
1104 | static bool get_is_migration_safe(Object *obj, Error **errp) |
1105 | { | |
1106 | return S390_CPU_GET_CLASS(obj)->is_migration_safe; | |
1107 | } | |
1108 | ||
1109 | static bool get_is_static(Object *obj, Error **errp) | |
1110 | { | |
1111 | return S390_CPU_GET_CLASS(obj)->is_static; | |
1112 | } | |
1113 | ||
1114 | static char *get_description(Object *obj, Error **errp) | |
1115 | { | |
1116 | return g_strdup(S390_CPU_GET_CLASS(obj)->desc); | |
1117 | } | |
1118 | ||
1119 | void s390_cpu_model_class_register_props(ObjectClass *oc) | |
1120 | { | |
1121 | object_class_property_add_bool(oc, "migration-safe", get_is_migration_safe, | |
1122 | NULL, NULL); | |
1123 | object_class_property_add_bool(oc, "static", get_is_static, | |
1124 | NULL, NULL); | |
1125 | object_class_property_add_str(oc, "description", get_description, NULL, | |
1126 | NULL); | |
1127 | } | |
1128 | ||
41868f84 DH |
1129 | #ifdef CONFIG_KVM |
1130 | static void s390_host_cpu_model_class_init(ObjectClass *oc, void *data) | |
1131 | { | |
1132 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
1133 | ||
1134 | xcc->kvm_required = true; | |
1135 | xcc->desc = "KVM only: All recognized features"; | |
1136 | } | |
1137 | #endif | |
1138 | ||
6c064de1 DH |
1139 | static void s390_base_cpu_model_class_init(ObjectClass *oc, void *data) |
1140 | { | |
1141 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
1142 | ||
1143 | /* all base models are migration safe */ | |
1144 | xcc->cpu_def = (const S390CPUDef *) data; | |
1145 | xcc->is_migration_safe = true; | |
1146 | xcc->is_static = true; | |
1147 | xcc->desc = xcc->cpu_def->desc; | |
1148 | } | |
1149 | ||
1150 | static void s390_cpu_model_class_init(ObjectClass *oc, void *data) | |
1151 | { | |
1152 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
1153 | ||
1154 | /* model that can change between QEMU versions */ | |
1155 | xcc->cpu_def = (const S390CPUDef *) data; | |
1156 | xcc->is_migration_safe = true; | |
1157 | xcc->desc = xcc->cpu_def->desc; | |
1158 | } | |
1159 | ||
41868f84 DH |
1160 | static void s390_qemu_cpu_model_class_init(ObjectClass *oc, void *data) |
1161 | { | |
1162 | S390CPUClass *xcc = S390_CPU_CLASS(oc); | |
1163 | ||
1164 | xcc->is_migration_safe = true; | |
1165 | xcc->desc = g_strdup_printf("QEMU Virtual CPU version %s", | |
1166 | qemu_hw_version()); | |
1167 | } | |
1168 | ||
1169 | #define S390_CPU_TYPE_SUFFIX "-" TYPE_S390_CPU | |
1170 | #define S390_CPU_TYPE_NAME(name) (name S390_CPU_TYPE_SUFFIX) | |
1171 | ||
1172 | /* Generate type name for a cpu model. Caller has to free the string. */ | |
1173 | static char *s390_cpu_type_name(const char *model_name) | |
1174 | { | |
1175 | return g_strdup_printf(S390_CPU_TYPE_NAME("%s"), model_name); | |
1176 | } | |
1177 | ||
6c064de1 DH |
1178 | /* Generate type name for a base cpu model. Caller has to free the string. */ |
1179 | static char *s390_base_cpu_type_name(const char *model_name) | |
1180 | { | |
1181 | return g_strdup_printf(S390_CPU_TYPE_NAME("%s-base"), model_name); | |
1182 | } | |
1183 | ||
41868f84 DH |
1184 | ObjectClass *s390_cpu_class_by_name(const char *name) |
1185 | { | |
1186 | char *typename = s390_cpu_type_name(name); | |
1187 | ObjectClass *oc; | |
1188 | ||
1189 | oc = object_class_by_name(typename); | |
1190 | g_free(typename); | |
1191 | return oc; | |
1192 | } | |
1193 | ||
1194 | static const TypeInfo qemu_s390_cpu_type_info = { | |
1195 | .name = S390_CPU_TYPE_NAME("qemu"), | |
1196 | .parent = TYPE_S390_CPU, | |
1197 | .instance_init = s390_qemu_cpu_model_initfn, | |
1198 | .instance_finalize = s390_cpu_model_finalize, | |
1199 | .class_init = s390_qemu_cpu_model_class_init, | |
1200 | }; | |
1201 | ||
1202 | #ifdef CONFIG_KVM | |
1203 | static const TypeInfo host_s390_cpu_type_info = { | |
1204 | .name = S390_CPU_TYPE_NAME("host"), | |
1205 | .parent = TYPE_S390_CPU, | |
1206 | .instance_init = s390_host_cpu_model_initfn, | |
1207 | .instance_finalize = s390_cpu_model_finalize, | |
1208 | .class_init = s390_host_cpu_model_class_init, | |
1209 | }; | |
1210 | #endif | |
1211 | ||
1212 | static void register_types(void) | |
1213 | { | |
6c064de1 DH |
1214 | int i; |
1215 | ||
1216 | /* init all bitmaps from gnerated data initially */ | |
1217 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
1218 | s390_init_feat_bitmap(s390_cpu_defs[i].base_init, | |
1219 | s390_cpu_defs[i].base_feat); | |
1220 | s390_init_feat_bitmap(s390_cpu_defs[i].default_init, | |
1221 | s390_cpu_defs[i].default_feat); | |
1222 | s390_init_feat_bitmap(s390_cpu_defs[i].full_init, | |
1223 | s390_cpu_defs[i].full_feat); | |
1224 | } | |
1225 | ||
1226 | for (i = 0; i < ARRAY_SIZE(s390_cpu_defs); i++) { | |
1227 | char *base_name = s390_base_cpu_type_name(s390_cpu_defs[i].name); | |
1228 | TypeInfo ti_base = { | |
1229 | .name = base_name, | |
1230 | .parent = TYPE_S390_CPU, | |
1231 | .instance_init = s390_cpu_model_initfn, | |
1232 | .instance_finalize = s390_cpu_model_finalize, | |
1233 | .class_init = s390_base_cpu_model_class_init, | |
1234 | .class_data = (void *) &s390_cpu_defs[i], | |
1235 | }; | |
1236 | char *name = s390_cpu_type_name(s390_cpu_defs[i].name); | |
1237 | TypeInfo ti = { | |
1238 | .name = name, | |
1239 | .parent = TYPE_S390_CPU, | |
1240 | .instance_init = s390_cpu_model_initfn, | |
1241 | .instance_finalize = s390_cpu_model_finalize, | |
1242 | .class_init = s390_cpu_model_class_init, | |
1243 | .class_data = (void *) &s390_cpu_defs[i], | |
1244 | }; | |
1245 | ||
1246 | type_register_static(&ti_base); | |
1247 | type_register_static(&ti); | |
1248 | g_free(base_name); | |
1249 | g_free(name); | |
1250 | } | |
1251 | ||
41868f84 DH |
1252 | type_register_static(&qemu_s390_cpu_type_info); |
1253 | #ifdef CONFIG_KVM | |
1254 | type_register_static(&host_s390_cpu_type_info); | |
1255 | #endif | |
1256 | } | |
1257 | ||
1258 | type_init(register_types) |