1 /*
2  * CPU models for s390x - System Emulation-only
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 "s390x-internal.h"
16 #include "kvm/kvm_s390x.h"
17 #include "sysemu/kvm.h"
18 #include "qapi/error.h"
19 #include "qapi/visitor.h"
20 #include "qapi/qobject-input-visitor.h"
21 #include "qapi/qmp/qdict.h"
22 #include "qapi/qapi-commands-machine-target.h"
23 
24 static void list_add_feat(const char *name, void *opaque);
25 
26 static void check_unavailable_features(const S390CPUModel *max_model,
27                                        const S390CPUModel *model,
28                                        strList **unavailable)
29 {
30     S390FeatBitmap missing;
31 
32     /* check general model compatibility */
33     if (max_model->def->gen < model->def->gen ||
34         (max_model->def->gen == model->def->gen &&
35          max_model->def->ec_ga < model->def->ec_ga)) {
36         list_add_feat("type", unavailable);
37     }
38 
39     /* detect missing features if any to properly report them */
40     bitmap_andnot(missing, model->features, max_model->features,
41                   S390_FEAT_MAX);
42     if (!bitmap_empty(missing, S390_FEAT_MAX)) {
43         s390_feat_bitmap_to_ascii(missing, unavailable, list_add_feat);
44     }
45 }
46 
47 struct CpuDefinitionInfoListData {
48     CpuDefinitionInfoList *list;
49     S390CPUModel *model;
50 };
51 
52 static void create_cpu_model_list(ObjectClass *klass, void *opaque)
53 {
54     struct CpuDefinitionInfoListData *cpu_list_data = opaque;
55     CpuDefinitionInfoList **cpu_list = &cpu_list_data->list;
56     CpuDefinitionInfo *info;
57     char *name = g_strdup(object_class_get_name(klass));
58     S390CPUClass *scc = S390_CPU_CLASS(klass);
59 
60     /* strip off the -s390x-cpu */
61     g_strrstr(name, "-" TYPE_S390_CPU)[0] = 0;
62     info = g_new0(CpuDefinitionInfo, 1);
63     info->name = name;
64     info->has_migration_safe = true;
65     info->migration_safe = scc->is_migration_safe;
66     info->q_static = scc->is_static;
67     info->q_typename = g_strdup(object_class_get_name(klass));
68     /* check for unavailable features */
69     if (cpu_list_data->model) {
70         Object *obj;
71         S390CPU *sc;
72         obj = object_new_with_class(klass);
73         sc = S390_CPU(obj);
74         if (sc->model) {
75             info->has_unavailable_features = true;
76             check_unavailable_features(cpu_list_data->model, sc->model,
77                                        &info->unavailable_features);
78         }
79         object_unref(obj);
80     }
81 
82     QAPI_LIST_PREPEND(*cpu_list, info);
83 }
84 
85 CpuDefinitionInfoList *qmp_query_cpu_definitions(Error **errp)
86 {
87     struct CpuDefinitionInfoListData list_data = {
88         .list = NULL,
89     };
90 
91     list_data.model = get_max_cpu_model(NULL);
92 
93     object_class_foreach(create_cpu_model_list, TYPE_S390_CPU, false,
94                          &list_data);
95 
96     return list_data.list;
97 }
98 
99 static void cpu_model_from_info(S390CPUModel *model, const CpuModelInfo *info,
100                                 const char *info_arg_name, Error **errp)
101 {
102     Error *err = NULL;
103     const QDict *qdict;
104     const QDictEntry *e;
105     Visitor *visitor;
106     ObjectClass *oc;
107     S390CPU *cpu;
108     Object *obj;
109 
110     oc = cpu_class_by_name(TYPE_S390_CPU, info->name);
111     if (!oc) {
112         error_setg(errp, "The CPU definition \'%s\' is unknown.", info->name);
113         return;
114     }
115     if (S390_CPU_CLASS(oc)->kvm_required && !kvm_enabled()) {
116         error_setg(errp, "The CPU definition '%s' requires KVM", info->name);
117         return;
118     }
119     obj = object_new_with_class(oc);
120     cpu = S390_CPU(obj);
121 
122     if (!cpu->model) {
123         error_setg(errp, "Details about the host CPU model are not available, "
124                          "it cannot be used.");
125         object_unref(obj);
126         return;
127     }
128 
129     if (info->props) {
130         g_autofree const char *props_name = g_strdup_printf("%s.props",
131                                                             info_arg_name);
132 
133         visitor = qobject_input_visitor_new(info->props);
134         if (!visit_start_struct(visitor, props_name, NULL, 0, errp)) {
135             visit_free(visitor);
136             object_unref(obj);
137             return;
138         }
139         qdict = qobject_to(QDict, info->props);
140         for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) {
141             if (!object_property_set(obj, e->key, visitor, &err)) {
142                 break;
143             }
144         }
145         if (!err) {
146             visit_check_struct(visitor, &err);
147         }
148         visit_end_struct(visitor, NULL);
149         visit_free(visitor);
150         if (err) {
151             error_propagate(errp, err);
152             object_unref(obj);
153             return;
154         }
155     }
156 
157     /* copy the model and throw the cpu away */
158     memcpy(model, cpu->model, sizeof(*model));
159     object_unref(obj);
160 }
161 
162 static void qdict_add_disabled_feat(const char *name, void *opaque)
163 {
164     qdict_put_bool(opaque, name, false);
165 }
166 
167 static void qdict_add_enabled_feat(const char *name, void *opaque)
168 {
169     qdict_put_bool(opaque, name, true);
170 }
171 
172 /* convert S390CPUDef into a static CpuModelInfo */
173 static void cpu_info_from_model(CpuModelInfo *info, const S390CPUModel *model,
174                                 bool delta_changes)
175 {
176     QDict *qdict = qdict_new();
177     S390FeatBitmap bitmap, deprecated;
178 
179     /* always fallback to the static base model */
180     info->name = g_strdup_printf("%s-base", model->def->name);
181 
182     /* features flagged as deprecated */
183     bitmap_zero(deprecated, S390_FEAT_MAX);
184     s390_get_deprecated_features(deprecated);
185 
186     if (delta_changes) {
187         /* features deleted from the base feature set */
188         bitmap_andnot(bitmap, model->def->base_feat, model->features,
189                       S390_FEAT_MAX);
190         if (!bitmap_empty(bitmap, S390_FEAT_MAX)) {
191             s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat);
192         }
193 
194         /* features added to the base feature set */
195         bitmap_andnot(bitmap, model->features, model->def->base_feat,
196                       S390_FEAT_MAX);
197         if (!bitmap_empty(bitmap, S390_FEAT_MAX)) {
198             s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_enabled_feat);
199         }
200 
201         /* deprecated features that are a subset of the model's enabled features */
202         bitmap_and(deprecated, deprecated, model->features, S390_FEAT_MAX);
203     } else {
204         /* expand all features */
205         s390_feat_bitmap_to_ascii(model->features, qdict,
206                                   qdict_add_enabled_feat);
207         bitmap_complement(bitmap, model->features, S390_FEAT_MAX);
208         s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat);
209     }
210 
211     if (!qdict_size(qdict)) {
212         qobject_unref(qdict);
213     } else {
214         info->props = QOBJECT(qdict);
215     }
216 
217     s390_feat_bitmap_to_ascii(deprecated, &info->deprecated_props, list_add_feat);
218     info->has_deprecated_props = !!info->deprecated_props;
219 }
220 
221 CpuModelExpansionInfo *qmp_query_cpu_model_expansion(CpuModelExpansionType type,
222                                                       CpuModelInfo *model,
223                                                       Error **errp)
224 {
225     Error *err = NULL;
226     CpuModelExpansionInfo *expansion_info = NULL;
227     S390CPUModel s390_model;
228     bool delta_changes = false;
229 
230     /* convert it to our internal representation */
231     cpu_model_from_info(&s390_model, model, "model", &err);
232     if (err) {
233         error_propagate(errp, err);
234         return NULL;
235     }
236 
237     if (type == CPU_MODEL_EXPANSION_TYPE_STATIC) {
238         delta_changes = true;
239     } else if (type != CPU_MODEL_EXPANSION_TYPE_FULL) {
240         error_setg(errp, "The requested expansion type is not supported.");
241         return NULL;
242     }
243 
244     /* convert it back to a static representation */
245     expansion_info = g_new0(CpuModelExpansionInfo, 1);
246     expansion_info->model = g_malloc0(sizeof(*expansion_info->model));
247     cpu_info_from_model(expansion_info->model, &s390_model, delta_changes);
248     return expansion_info;
249 }
250 
251 static void list_add_feat(const char *name, void *opaque)
252 {
253     strList **last = (strList **) opaque;
254 
255     QAPI_LIST_PREPEND(*last, g_strdup(name));
256 }
257 
258 CpuModelCompareInfo *qmp_query_cpu_model_comparison(CpuModelInfo *infoa,
259                                                      CpuModelInfo *infob,
260                                                      Error **errp)
261 {
262     Error *err = NULL;
263     CpuModelCompareResult feat_result, gen_result;
264     CpuModelCompareInfo *compare_info;
265     S390FeatBitmap missing, added;
266     S390CPUModel modela, modelb;
267 
268     /* convert both models to our internal representation */
269     cpu_model_from_info(&modela, infoa, "modela", &err);
270     if (err) {
271         error_propagate(errp, err);
272         return NULL;
273     }
274     cpu_model_from_info(&modelb, infob, "modelb", &err);
275     if (err) {
276         error_propagate(errp, err);
277         return NULL;
278     }
279     compare_info = g_new0(CpuModelCompareInfo, 1);
280 
281     /* check the cpu generation and ga level */
282     if (modela.def->gen == modelb.def->gen) {
283         if (modela.def->ec_ga == modelb.def->ec_ga) {
284             /* ec and corresponding bc are identical */
285             gen_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL;
286         } else if (modela.def->ec_ga < modelb.def->ec_ga) {
287             gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET;
288         } else {
289             gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET;
290         }
291     } else if (modela.def->gen < modelb.def->gen) {
292         gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET;
293     } else {
294         gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET;
295     }
296     if (gen_result != CPU_MODEL_COMPARE_RESULT_IDENTICAL) {
297         /* both models cannot be made identical */
298         list_add_feat("type", &compare_info->responsible_properties);
299     }
300 
301     /* check the feature set */
302     if (bitmap_equal(modela.features, modelb.features, S390_FEAT_MAX)) {
303         feat_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL;
304     } else {
305         bitmap_andnot(missing, modela.features, modelb.features, S390_FEAT_MAX);
306         s390_feat_bitmap_to_ascii(missing,
307                                   &compare_info->responsible_properties,
308                                   list_add_feat);
309         bitmap_andnot(added, modelb.features, modela.features, S390_FEAT_MAX);
310         s390_feat_bitmap_to_ascii(added, &compare_info->responsible_properties,
311                                   list_add_feat);
312         if (bitmap_empty(missing, S390_FEAT_MAX)) {
313             feat_result = CPU_MODEL_COMPARE_RESULT_SUBSET;
314         } else if (bitmap_empty(added, S390_FEAT_MAX)) {
315             feat_result = CPU_MODEL_COMPARE_RESULT_SUPERSET;
316         } else {
317             feat_result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE;
318         }
319     }
320 
321     /* combine the results */
322     if (gen_result == feat_result) {
323         compare_info->result = gen_result;
324     } else if (feat_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) {
325         compare_info->result = gen_result;
326     } else if (gen_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) {
327         compare_info->result = feat_result;
328     } else {
329         compare_info->result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE;
330     }
331     return compare_info;
332 }
333 
334 CpuModelBaselineInfo *qmp_query_cpu_model_baseline(CpuModelInfo *infoa,
335                                                     CpuModelInfo *infob,
336                                                     Error **errp)
337 {
338     Error *err = NULL;
339     CpuModelBaselineInfo *baseline_info;
340     S390CPUModel modela, modelb, model;
341     uint16_t cpu_type;
342     uint8_t max_gen_ga;
343     uint8_t max_gen;
344 
345     /* convert both models to our internal representation */
346     cpu_model_from_info(&modela, infoa, "modela", &err);
347     if (err) {
348         error_propagate(errp, err);
349         return NULL;
350     }
351 
352     cpu_model_from_info(&modelb, infob, "modelb", &err);
353     if (err) {
354         error_propagate(errp, err);
355         return NULL;
356     }
357 
358     /* features both models support */
359     bitmap_and(model.features, modela.features, modelb.features, S390_FEAT_MAX);
360 
361     /* detect the maximum model not regarding features */
362     if (modela.def->gen == modelb.def->gen) {
363         if (modela.def->type == modelb.def->type) {
364             cpu_type = modela.def->type;
365         } else {
366             cpu_type = 0;
367         }
368         max_gen = modela.def->gen;
369         max_gen_ga = MIN(modela.def->ec_ga, modelb.def->ec_ga);
370     } else if (modela.def->gen > modelb.def->gen) {
371         cpu_type = modelb.def->type;
372         max_gen = modelb.def->gen;
373         max_gen_ga = modelb.def->ec_ga;
374     } else {
375         cpu_type = modela.def->type;
376         max_gen = modela.def->gen;
377         max_gen_ga = modela.def->ec_ga;
378     }
379 
380     model.def = s390_find_cpu_def(cpu_type, max_gen, max_gen_ga,
381                                   model.features);
382 
383     /* models without early base features (esan3) are bad */
384     if (!model.def) {
385         error_setg(errp, "No compatible CPU model could be created as"
386                    " important base features are disabled");
387         return NULL;
388     }
389 
390     /* strip off features not part of the max model */
391     bitmap_and(model.features, model.features, model.def->full_feat,
392                S390_FEAT_MAX);
393 
394     baseline_info = g_new0(CpuModelBaselineInfo, 1);
395     baseline_info->model = g_malloc0(sizeof(*baseline_info->model));
396     cpu_info_from_model(baseline_info->model, &model, true);
397     return baseline_info;
398 }
399 
400 void apply_cpu_model(const S390CPUModel *model, Error **errp)
401 {
402     static S390CPUModel applied_model;
403     static bool applied;
404 
405     /*
406      * We have the same model for all VCPUs. KVM can only be configured before
407      * any VCPUs are defined in KVM.
408      */
409     if (applied) {
410         if (model && memcmp(&applied_model, model, sizeof(S390CPUModel))) {
411             error_setg(errp, "Mixed CPU models are not supported on s390x.");
412         }
413         return;
414     }
415 
416     if (kvm_enabled()) {
417         if (!kvm_s390_apply_cpu_model(model, errp)) {
418             return;
419         }
420     }
421 
422     applied = true;
423     if (model) {
424         applied_model = *model;
425     }
426 }
427