1 /*
2 * QEMU monitor.c for ARM.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 * THE SOFTWARE.
21 */
22
23 #include "qemu/osdep.h"
24 #include "hw/boards.h"
25 #include "kvm_arm.h"
26 #include "qapi/error.h"
27 #include "qapi/visitor.h"
28 #include "qapi/qobject-input-visitor.h"
29 #include "qapi/qapi-commands-machine.h"
30 #include "qapi/qapi-commands-misc-arm.h"
31 #include "qobject/qdict.h"
32 #include "qom/qom-qobject.h"
33 #include "cpu.h"
34
gic_cap_new(int version)35 static GICCapability *gic_cap_new(int version)
36 {
37 GICCapability *cap = g_new0(GICCapability, 1);
38 cap->version = version;
39 /* by default, support none */
40 cap->emulated = false;
41 cap->kernel = false;
42 return cap;
43 }
44
gic_cap_kvm_probe(GICCapability * v2,GICCapability * v3)45 static inline void gic_cap_kvm_probe(GICCapability *v2, GICCapability *v3)
46 {
47 #ifdef CONFIG_KVM
48 int fdarray[3];
49
50 if (!kvm_arm_create_scratch_host_vcpu(fdarray, NULL)) {
51 return;
52 }
53
54 /* Test KVM GICv2 */
55 if (kvm_device_supported(fdarray[1], KVM_DEV_TYPE_ARM_VGIC_V2)) {
56 v2->kernel = true;
57 }
58
59 /* Test KVM GICv3 */
60 if (kvm_device_supported(fdarray[1], KVM_DEV_TYPE_ARM_VGIC_V3)) {
61 v3->kernel = true;
62 }
63
64 kvm_arm_destroy_scratch_host_vcpu(fdarray);
65 #endif
66 }
67
qmp_query_gic_capabilities(Error ** errp)68 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
69 {
70 GICCapabilityList *head = NULL;
71 GICCapability *v2 = gic_cap_new(2), *v3 = gic_cap_new(3);
72
73 v2->emulated = true;
74 v3->emulated = true;
75
76 gic_cap_kvm_probe(v2, v3);
77
78 QAPI_LIST_PREPEND(head, v2);
79 QAPI_LIST_PREPEND(head, v3);
80
81 return head;
82 }
83
84 QEMU_BUILD_BUG_ON(ARM_MAX_VQ > 16);
85
86 /*
87 * These are cpu model features we want to advertise. The order here
88 * matters as this is the order in which qmp_query_cpu_model_expansion
89 * will attempt to set them. If there are dependencies between features,
90 * then the order that considers those dependencies must be used.
91 */
92 static const char *cpu_model_advertised_features[] = {
93 "aarch64", "pmu", "sve",
94 "sve128", "sve256", "sve384", "sve512",
95 "sve640", "sve768", "sve896", "sve1024", "sve1152", "sve1280",
96 "sve1408", "sve1536", "sve1664", "sve1792", "sve1920", "sve2048",
97 "kvm-no-adjvtime", "kvm-steal-time",
98 "pauth", "pauth-impdef", "pauth-qarma3", "pauth-qarma5",
99 NULL
100 };
101
qmp_query_cpu_model_expansion(CpuModelExpansionType type,CpuModelInfo * model,Error ** errp)102 CpuModelExpansionInfo *qmp_query_cpu_model_expansion(CpuModelExpansionType type,
103 CpuModelInfo *model,
104 Error **errp)
105 {
106 CpuModelExpansionInfo *expansion_info;
107 const QDict *qdict_in;
108 QDict *qdict_out;
109 ObjectClass *oc;
110 Object *obj;
111 const char *name;
112 int i;
113
114 if (type != CPU_MODEL_EXPANSION_TYPE_FULL) {
115 error_setg(errp, "The requested expansion type is not supported");
116 return NULL;
117 }
118
119 if (!kvm_enabled() && !strcmp(model->name, "host")) {
120 error_setg(errp, "The CPU type '%s' requires KVM", model->name);
121 return NULL;
122 }
123
124 oc = cpu_class_by_name(TYPE_ARM_CPU, model->name);
125 if (!oc) {
126 error_setg(errp, "The CPU type '%s' is not a recognized ARM CPU type",
127 model->name);
128 return NULL;
129 }
130
131 if (kvm_enabled()) {
132 bool supported = false;
133
134 if (!strcmp(model->name, "host") || !strcmp(model->name, "max")) {
135 /* These are kvmarm's recommended cpu types */
136 supported = true;
137 } else if (current_machine->cpu_type) {
138 const char *cpu_type = current_machine->cpu_type;
139 int len = strlen(cpu_type) - strlen(ARM_CPU_TYPE_SUFFIX);
140
141 if (strlen(model->name) == len &&
142 !strncmp(model->name, cpu_type, len)) {
143 /* KVM is enabled and we're using this type, so it works. */
144 supported = true;
145 }
146 }
147 if (!supported) {
148 error_setg(errp, "We cannot guarantee the CPU type '%s' works "
149 "with KVM on this host", model->name);
150 return NULL;
151 }
152 }
153
154 obj = object_new(object_class_get_name(oc));
155
156 if (model->props) {
157 Visitor *visitor;
158 Error *err = NULL;
159
160 visitor = qobject_input_visitor_new(model->props);
161 if (!visit_start_struct(visitor, "model.props", NULL, 0, errp)) {
162 visit_free(visitor);
163 object_unref(obj);
164 return NULL;
165 }
166
167 qdict_in = qobject_to(QDict, model->props);
168 i = 0;
169 while ((name = cpu_model_advertised_features[i++]) != NULL) {
170 if (qdict_get(qdict_in, name)) {
171 if (!object_property_set(obj, name, visitor, &err)) {
172 break;
173 }
174 }
175 }
176
177 if (!err) {
178 visit_check_struct(visitor, &err);
179 }
180 if (!err) {
181 arm_cpu_finalize_features(ARM_CPU(obj), &err);
182 }
183 visit_end_struct(visitor, NULL);
184 visit_free(visitor);
185 if (err) {
186 object_unref(obj);
187 error_propagate(errp, err);
188 return NULL;
189 }
190 } else {
191 arm_cpu_finalize_features(ARM_CPU(obj), &error_abort);
192 }
193
194 expansion_info = g_new0(CpuModelExpansionInfo, 1);
195 expansion_info->model = g_malloc0(sizeof(*expansion_info->model));
196 expansion_info->model->name = g_strdup(model->name);
197
198 qdict_out = qdict_new();
199
200 i = 0;
201 while ((name = cpu_model_advertised_features[i++]) != NULL) {
202 ObjectProperty *prop = object_property_find(obj, name);
203 if (prop) {
204 QObject *value;
205
206 assert(prop->get);
207 value = object_property_get_qobject(obj, name, &error_abort);
208
209 qdict_put_obj(qdict_out, name, value);
210 }
211 }
212
213 if (!qdict_size(qdict_out)) {
214 qobject_unref(qdict_out);
215 } else {
216 expansion_info->model->props = QOBJECT(qdict_out);
217 }
218
219 object_unref(obj);
220
221 return expansion_info;
222 }
223
arm_cpu_add_definition(gpointer data,gpointer user_data)224 static void arm_cpu_add_definition(gpointer data, gpointer user_data)
225 {
226 ObjectClass *oc = data;
227 CpuDefinitionInfoList **cpu_list = user_data;
228 CpuDefinitionInfo *info;
229 const char *typename;
230
231 typename = object_class_get_name(oc);
232 info = g_malloc0(sizeof(*info));
233 info->name = cpu_model_from_type(typename);
234 info->q_typename = g_strdup(typename);
235
236 QAPI_LIST_PREPEND(*cpu_list, info);
237 }
238
qmp_query_cpu_definitions(Error ** errp)239 CpuDefinitionInfoList *qmp_query_cpu_definitions(Error **errp)
240 {
241 CpuDefinitionInfoList *cpu_list = NULL;
242 GSList *list;
243
244 list = object_class_get_list(TYPE_ARM_CPU, false);
245 g_slist_foreach(list, arm_cpu_add_definition, &cpu_list);
246 g_slist_free(list);
247
248 return cpu_list;
249 }
250