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;
178 
179     /* always fallback to the static base model */
180     info->name = g_strdup_printf("%s-base", model->def->name);
181 
182     if (delta_changes) {
183         /* features deleted from the base feature set */
184         bitmap_andnot(bitmap, model->def->base_feat, model->features,
185                       S390_FEAT_MAX);
186         if (!bitmap_empty(bitmap, S390_FEAT_MAX)) {
187             s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat);
188         }
189 
190         /* features added to the base feature set */
191         bitmap_andnot(bitmap, model->features, model->def->base_feat,
192                       S390_FEAT_MAX);
193         if (!bitmap_empty(bitmap, S390_FEAT_MAX)) {
194             s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_enabled_feat);
195         }
196     } else {
197         /* expand all features */
198         s390_feat_bitmap_to_ascii(model->features, qdict,
199                                   qdict_add_enabled_feat);
200         bitmap_complement(bitmap, model->features, S390_FEAT_MAX);
201         s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat);
202     }
203 
204     if (!qdict_size(qdict)) {
205         qobject_unref(qdict);
206     } else {
207         info->props = QOBJECT(qdict);
208     }
209 }
210 
211 CpuModelExpansionInfo *qmp_query_cpu_model_expansion(CpuModelExpansionType type,
212                                                       CpuModelInfo *model,
213                                                       Error **errp)
214 {
215     Error *err = NULL;
216     CpuModelExpansionInfo *expansion_info = NULL;
217     S390CPUModel s390_model;
218     bool delta_changes = false;
219 
220     /* convert it to our internal representation */
221     cpu_model_from_info(&s390_model, model, "model", &err);
222     if (err) {
223         error_propagate(errp, err);
224         return NULL;
225     }
226 
227     if (type == CPU_MODEL_EXPANSION_TYPE_STATIC) {
228         delta_changes = true;
229     } else if (type != CPU_MODEL_EXPANSION_TYPE_FULL) {
230         error_setg(errp, "The requested expansion type is not supported.");
231         return NULL;
232     }
233 
234     /* convert it back to a static representation */
235     expansion_info = g_new0(CpuModelExpansionInfo, 1);
236     expansion_info->model = g_malloc0(sizeof(*expansion_info->model));
237     cpu_info_from_model(expansion_info->model, &s390_model, delta_changes);
238     return expansion_info;
239 }
240 
241 static void list_add_feat(const char *name, void *opaque)
242 {
243     strList **last = (strList **) opaque;
244 
245     QAPI_LIST_PREPEND(*last, g_strdup(name));
246 }
247 
248 CpuModelCompareInfo *qmp_query_cpu_model_comparison(CpuModelInfo *infoa,
249                                                      CpuModelInfo *infob,
250                                                      Error **errp)
251 {
252     Error *err = NULL;
253     CpuModelCompareResult feat_result, gen_result;
254     CpuModelCompareInfo *compare_info;
255     S390FeatBitmap missing, added;
256     S390CPUModel modela, modelb;
257 
258     /* convert both models to our internal representation */
259     cpu_model_from_info(&modela, infoa, "modela", &err);
260     if (err) {
261         error_propagate(errp, err);
262         return NULL;
263     }
264     cpu_model_from_info(&modelb, infob, "modelb", &err);
265     if (err) {
266         error_propagate(errp, err);
267         return NULL;
268     }
269     compare_info = g_new0(CpuModelCompareInfo, 1);
270 
271     /* check the cpu generation and ga level */
272     if (modela.def->gen == modelb.def->gen) {
273         if (modela.def->ec_ga == modelb.def->ec_ga) {
274             /* ec and corresponding bc are identical */
275             gen_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL;
276         } else if (modela.def->ec_ga < modelb.def->ec_ga) {
277             gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET;
278         } else {
279             gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET;
280         }
281     } else if (modela.def->gen < modelb.def->gen) {
282         gen_result = CPU_MODEL_COMPARE_RESULT_SUBSET;
283     } else {
284         gen_result = CPU_MODEL_COMPARE_RESULT_SUPERSET;
285     }
286     if (gen_result != CPU_MODEL_COMPARE_RESULT_IDENTICAL) {
287         /* both models cannot be made identical */
288         list_add_feat("type", &compare_info->responsible_properties);
289     }
290 
291     /* check the feature set */
292     if (bitmap_equal(modela.features, modelb.features, S390_FEAT_MAX)) {
293         feat_result = CPU_MODEL_COMPARE_RESULT_IDENTICAL;
294     } else {
295         bitmap_andnot(missing, modela.features, modelb.features, S390_FEAT_MAX);
296         s390_feat_bitmap_to_ascii(missing,
297                                   &compare_info->responsible_properties,
298                                   list_add_feat);
299         bitmap_andnot(added, modelb.features, modela.features, S390_FEAT_MAX);
300         s390_feat_bitmap_to_ascii(added, &compare_info->responsible_properties,
301                                   list_add_feat);
302         if (bitmap_empty(missing, S390_FEAT_MAX)) {
303             feat_result = CPU_MODEL_COMPARE_RESULT_SUBSET;
304         } else if (bitmap_empty(added, S390_FEAT_MAX)) {
305             feat_result = CPU_MODEL_COMPARE_RESULT_SUPERSET;
306         } else {
307             feat_result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE;
308         }
309     }
310 
311     /* combine the results */
312     if (gen_result == feat_result) {
313         compare_info->result = gen_result;
314     } else if (feat_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) {
315         compare_info->result = gen_result;
316     } else if (gen_result == CPU_MODEL_COMPARE_RESULT_IDENTICAL) {
317         compare_info->result = feat_result;
318     } else {
319         compare_info->result = CPU_MODEL_COMPARE_RESULT_INCOMPATIBLE;
320     }
321     return compare_info;
322 }
323 
324 CpuModelBaselineInfo *qmp_query_cpu_model_baseline(CpuModelInfo *infoa,
325                                                     CpuModelInfo *infob,
326                                                     Error **errp)
327 {
328     Error *err = NULL;
329     CpuModelBaselineInfo *baseline_info;
330     S390CPUModel modela, modelb, model;
331     uint16_t cpu_type;
332     uint8_t max_gen_ga;
333     uint8_t max_gen;
334 
335     /* convert both models to our internal representation */
336     cpu_model_from_info(&modela, infoa, "modela", &err);
337     if (err) {
338         error_propagate(errp, err);
339         return NULL;
340     }
341 
342     cpu_model_from_info(&modelb, infob, "modelb", &err);
343     if (err) {
344         error_propagate(errp, err);
345         return NULL;
346     }
347 
348     /* features both models support */
349     bitmap_and(model.features, modela.features, modelb.features, S390_FEAT_MAX);
350 
351     /* detect the maximum model not regarding features */
352     if (modela.def->gen == modelb.def->gen) {
353         if (modela.def->type == modelb.def->type) {
354             cpu_type = modela.def->type;
355         } else {
356             cpu_type = 0;
357         }
358         max_gen = modela.def->gen;
359         max_gen_ga = MIN(modela.def->ec_ga, modelb.def->ec_ga);
360     } else if (modela.def->gen > modelb.def->gen) {
361         cpu_type = modelb.def->type;
362         max_gen = modelb.def->gen;
363         max_gen_ga = modelb.def->ec_ga;
364     } else {
365         cpu_type = modela.def->type;
366         max_gen = modela.def->gen;
367         max_gen_ga = modela.def->ec_ga;
368     }
369 
370     model.def = s390_find_cpu_def(cpu_type, max_gen, max_gen_ga,
371                                   model.features);
372 
373     /* models without early base features (esan3) are bad */
374     if (!model.def) {
375         error_setg(errp, "No compatible CPU model could be created as"
376                    " important base features are disabled");
377         return NULL;
378     }
379 
380     /* strip off features not part of the max model */
381     bitmap_and(model.features, model.features, model.def->full_feat,
382                S390_FEAT_MAX);
383 
384     baseline_info = g_new0(CpuModelBaselineInfo, 1);
385     baseline_info->model = g_malloc0(sizeof(*baseline_info->model));
386     cpu_info_from_model(baseline_info->model, &model, true);
387     return baseline_info;
388 }
389 
390 void apply_cpu_model(const S390CPUModel *model, Error **errp)
391 {
392     Error *err = NULL;
393     static S390CPUModel applied_model;
394     static bool applied;
395 
396     /*
397      * We have the same model for all VCPUs. KVM can only be configured before
398      * any VCPUs are defined in KVM.
399      */
400     if (applied) {
401         if (model && memcmp(&applied_model, model, sizeof(S390CPUModel))) {
402             error_setg(errp, "Mixed CPU models are not supported on s390x.");
403         }
404         return;
405     }
406 
407     if (kvm_enabled()) {
408         kvm_s390_apply_cpu_model(model, &err);
409         if (err) {
410             error_propagate(errp, err);
411             return;
412         }
413     }
414 
415     applied = true;
416     if (model) {
417         applied_model = *model;
418     }
419 }
420