]>
Commit | Line | Data |
---|---|---|
bd31b751 AJ |
1 | /* |
2 | * Arm CPU feature test cases | |
3 | * | |
4 | * Copyright (c) 2019 Red Hat Inc. | |
5 | * Authors: | |
6 | * Andrew Jones <drjones@redhat.com> | |
7 | * | |
8 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
9 | * See the COPYING file in the top-level directory. | |
10 | */ | |
11 | #include "qemu/osdep.h" | |
0df9142d | 12 | #include "qemu/bitops.h" |
907b5105 | 13 | #include "libqtest.h" |
bd31b751 AJ |
14 | #include "qapi/qmp/qdict.h" |
15 | #include "qapi/qmp/qjson.h" | |
16 | ||
0df9142d AJ |
17 | /* |
18 | * We expect the SVE max-vq to be 16. Also it must be <= 64 | |
19 | * for our test code, otherwise 'vls' can't just be a uint64_t. | |
20 | */ | |
21 | #define SVE_MAX_VQ 16 | |
22 | ||
6f6e1698 PB |
23 | #define MACHINE "-machine virt,gic-version=max -accel tcg " |
24 | #define MACHINE_KVM "-machine virt,gic-version=max -accel kvm -accel tcg " | |
bd31b751 AJ |
25 | #define QUERY_HEAD "{ 'execute': 'query-cpu-model-expansion', " \ |
26 | " 'arguments': { 'type': 'full', " | |
27 | #define QUERY_TAIL "}}" | |
28 | ||
bd31b751 AJ |
29 | static QDict *do_query_no_props(QTestState *qts, const char *cpu_type) |
30 | { | |
31 | return qtest_qmp(qts, QUERY_HEAD "'model': { 'name': %s }" | |
32 | QUERY_TAIL, cpu_type); | |
33 | } | |
34 | ||
0472b2e5 | 35 | G_GNUC_PRINTF(3, 4) |
bd31b751 AJ |
36 | static QDict *do_query(QTestState *qts, const char *cpu_type, |
37 | const char *fmt, ...) | |
38 | { | |
39 | QDict *resp; | |
40 | ||
41 | if (fmt) { | |
42 | QDict *args; | |
43 | va_list ap; | |
44 | ||
45 | va_start(ap, fmt); | |
46 | args = qdict_from_vjsonf_nofail(fmt, ap); | |
47 | va_end(ap); | |
48 | ||
49 | resp = qtest_qmp(qts, QUERY_HEAD "'model': { 'name': %s, " | |
50 | "'props': %p }" | |
51 | QUERY_TAIL, cpu_type, args); | |
52 | } else { | |
53 | resp = do_query_no_props(qts, cpu_type); | |
54 | } | |
55 | ||
56 | return resp; | |
57 | } | |
58 | ||
59 | static const char *resp_get_error(QDict *resp) | |
60 | { | |
61 | QDict *qdict; | |
62 | ||
63 | g_assert(resp); | |
64 | ||
65 | qdict = qdict_get_qdict(resp, "error"); | |
66 | if (qdict) { | |
67 | return qdict_get_str(qdict, "desc"); | |
68 | } | |
69 | ||
70 | return NULL; | |
71 | } | |
72 | ||
73 | #define assert_error(qts, cpu_type, expected_error, fmt, ...) \ | |
74 | ({ \ | |
75 | QDict *_resp; \ | |
76 | const char *_error; \ | |
77 | \ | |
78 | _resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__); \ | |
79 | g_assert(_resp); \ | |
80 | _error = resp_get_error(_resp); \ | |
81 | g_assert(_error); \ | |
82 | g_assert(g_str_equal(_error, expected_error)); \ | |
83 | qobject_unref(_resp); \ | |
84 | }) | |
85 | ||
86 | static bool resp_has_props(QDict *resp) | |
87 | { | |
88 | QDict *qdict; | |
89 | ||
90 | g_assert(resp); | |
91 | ||
92 | if (!qdict_haskey(resp, "return")) { | |
93 | return false; | |
94 | } | |
95 | qdict = qdict_get_qdict(resp, "return"); | |
96 | ||
97 | if (!qdict_haskey(qdict, "model")) { | |
98 | return false; | |
99 | } | |
100 | qdict = qdict_get_qdict(qdict, "model"); | |
101 | ||
102 | return qdict_haskey(qdict, "props"); | |
103 | } | |
104 | ||
105 | static QDict *resp_get_props(QDict *resp) | |
106 | { | |
107 | QDict *qdict; | |
108 | ||
109 | g_assert(resp); | |
110 | g_assert(resp_has_props(resp)); | |
111 | ||
112 | qdict = qdict_get_qdict(resp, "return"); | |
113 | qdict = qdict_get_qdict(qdict, "model"); | |
114 | qdict = qdict_get_qdict(qdict, "props"); | |
115 | ||
116 | return qdict; | |
117 | } | |
118 | ||
6fa8a379 AJ |
119 | static bool resp_get_feature(QDict *resp, const char *feature) |
120 | { | |
121 | QDict *props; | |
122 | ||
123 | g_assert(resp); | |
124 | g_assert(resp_has_props(resp)); | |
125 | props = resp_get_props(resp); | |
126 | g_assert(qdict_get(props, feature)); | |
127 | return qdict_get_bool(props, feature); | |
128 | } | |
129 | ||
bd31b751 AJ |
130 | #define assert_has_feature(qts, cpu_type, feature) \ |
131 | ({ \ | |
132 | QDict *_resp = do_query_no_props(qts, cpu_type); \ | |
133 | g_assert(_resp); \ | |
134 | g_assert(resp_has_props(_resp)); \ | |
135 | g_assert(qdict_get(resp_get_props(_resp), feature)); \ | |
136 | qobject_unref(_resp); \ | |
137 | }) | |
138 | ||
139 | #define assert_has_not_feature(qts, cpu_type, feature) \ | |
140 | ({ \ | |
141 | QDict *_resp = do_query_no_props(qts, cpu_type); \ | |
142 | g_assert(_resp); \ | |
143 | g_assert(!resp_has_props(_resp) || \ | |
144 | !qdict_get(resp_get_props(_resp), feature)); \ | |
145 | qobject_unref(_resp); \ | |
146 | }) | |
147 | ||
92a70997 | 148 | #define resp_assert_feature(resp, feature, expected_value) \ |
789a35ef | 149 | ({ \ |
92a70997 | 150 | QDict *_props; \ |
789a35ef | 151 | \ |
789a35ef AJ |
152 | g_assert(_resp); \ |
153 | g_assert(resp_has_props(_resp)); \ | |
154 | _props = resp_get_props(_resp); \ | |
155 | g_assert(qdict_get(_props, feature)); \ | |
156 | g_assert(qdict_get_bool(_props, feature) == (expected_value)); \ | |
92a70997 AJ |
157 | }) |
158 | ||
159 | #define assert_feature(qts, cpu_type, feature, expected_value) \ | |
160 | ({ \ | |
161 | QDict *_resp; \ | |
162 | \ | |
163 | _resp = do_query_no_props(qts, cpu_type); \ | |
164 | g_assert(_resp); \ | |
165 | resp_assert_feature(_resp, feature, expected_value); \ | |
166 | qobject_unref(_resp); \ | |
167 | }) | |
168 | ||
169 | #define assert_set_feature(qts, cpu_type, feature, value) \ | |
170 | ({ \ | |
171 | const char *_fmt = (value) ? "{ %s: true }" : "{ %s: false }"; \ | |
172 | QDict *_resp; \ | |
173 | \ | |
174 | _resp = do_query(qts, cpu_type, _fmt, feature); \ | |
175 | g_assert(_resp); \ | |
176 | resp_assert_feature(_resp, feature, value); \ | |
789a35ef AJ |
177 | qobject_unref(_resp); \ |
178 | }) | |
179 | ||
180 | #define assert_has_feature_enabled(qts, cpu_type, feature) \ | |
181 | assert_feature(qts, cpu_type, feature, true) | |
182 | ||
183 | #define assert_has_feature_disabled(qts, cpu_type, feature) \ | |
184 | assert_feature(qts, cpu_type, feature, false) | |
185 | ||
bd31b751 AJ |
186 | static void assert_type_full(QTestState *qts) |
187 | { | |
188 | const char *error; | |
189 | QDict *resp; | |
190 | ||
191 | resp = qtest_qmp(qts, "{ 'execute': 'query-cpu-model-expansion', " | |
192 | "'arguments': { 'type': 'static', " | |
193 | "'model': { 'name': 'foo' }}}"); | |
194 | g_assert(resp); | |
195 | error = resp_get_error(resp); | |
196 | g_assert(error); | |
197 | g_assert(g_str_equal(error, | |
198 | "The requested expansion type is not supported")); | |
199 | qobject_unref(resp); | |
200 | } | |
201 | ||
202 | static void assert_bad_props(QTestState *qts, const char *cpu_type) | |
203 | { | |
204 | const char *error; | |
205 | QDict *resp; | |
206 | ||
207 | resp = qtest_qmp(qts, "{ 'execute': 'query-cpu-model-expansion', " | |
208 | "'arguments': { 'type': 'full', " | |
209 | "'model': { 'name': %s, " | |
210 | "'props': false }}}", | |
211 | cpu_type); | |
212 | g_assert(resp); | |
213 | error = resp_get_error(resp); | |
214 | g_assert(error); | |
215 | g_assert(g_str_equal(error, | |
216 | "Invalid parameter type for 'props', expected: dict")); | |
217 | qobject_unref(resp); | |
218 | } | |
219 | ||
0df9142d AJ |
220 | static uint64_t resp_get_sve_vls(QDict *resp) |
221 | { | |
222 | QDict *props; | |
223 | const QDictEntry *e; | |
224 | uint64_t vls = 0; | |
225 | int n = 0; | |
226 | ||
227 | g_assert(resp); | |
228 | g_assert(resp_has_props(resp)); | |
229 | ||
230 | props = resp_get_props(resp); | |
231 | ||
232 | for (e = qdict_first(props); e; e = qdict_next(props, e)) { | |
233 | if (strlen(e->key) > 3 && !strncmp(e->key, "sve", 3) && | |
234 | g_ascii_isdigit(e->key[3])) { | |
235 | char *endptr; | |
236 | int bits; | |
237 | ||
238 | bits = g_ascii_strtoll(&e->key[3], &endptr, 10); | |
239 | if (!bits || *endptr != '\0') { | |
240 | continue; | |
241 | } | |
242 | ||
243 | if (qdict_get_bool(props, e->key)) { | |
244 | vls |= BIT_ULL((bits / 128) - 1); | |
245 | } | |
246 | ++n; | |
247 | } | |
248 | } | |
249 | ||
250 | g_assert(n == SVE_MAX_VQ); | |
251 | ||
252 | return vls; | |
253 | } | |
254 | ||
255 | #define assert_sve_vls(qts, cpu_type, expected_vls, fmt, ...) \ | |
256 | ({ \ | |
257 | QDict *_resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__); \ | |
258 | g_assert(_resp); \ | |
259 | g_assert(resp_has_props(_resp)); \ | |
260 | g_assert(resp_get_sve_vls(_resp) == expected_vls); \ | |
261 | qobject_unref(_resp); \ | |
262 | }) | |
263 | ||
264 | static void sve_tests_default(QTestState *qts, const char *cpu_type) | |
265 | { | |
266 | /* | |
267 | * With no sve-max-vq or sve<N> properties on the command line | |
268 | * the default is to have all vector lengths enabled. This also | |
269 | * tests that 'sve' is 'on' by default. | |
270 | */ | |
271 | assert_sve_vls(qts, cpu_type, BIT_ULL(SVE_MAX_VQ) - 1, NULL); | |
272 | ||
273 | /* With SVE off, all vector lengths should also be off. */ | |
274 | assert_sve_vls(qts, cpu_type, 0, "{ 'sve': false }"); | |
275 | ||
276 | /* With SVE on, we must have at least one vector length enabled. */ | |
277 | assert_error(qts, cpu_type, "cannot disable sve128", "{ 'sve128': false }"); | |
278 | ||
279 | /* Basic enable/disable tests. */ | |
280 | assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve384': true }"); | |
281 | assert_sve_vls(qts, cpu_type, ((BIT_ULL(SVE_MAX_VQ) - 1) & ~BIT_ULL(2)), | |
282 | "{ 'sve384': false }"); | |
283 | ||
284 | /* | |
285 | * --------------------------------------------------------------------- | |
286 | * power-of-two(vq) all-power- can can | |
287 | * of-two(< vq) enable disable | |
288 | * --------------------------------------------------------------------- | |
289 | * vq < max_vq no MUST* yes yes | |
290 | * vq < max_vq yes MUST* yes no | |
291 | * --------------------------------------------------------------------- | |
292 | * vq == max_vq n/a MUST* yes** yes** | |
293 | * --------------------------------------------------------------------- | |
294 | * vq > max_vq n/a no no yes | |
295 | * vq > max_vq n/a yes yes yes | |
296 | * --------------------------------------------------------------------- | |
297 | * | |
298 | * [*] "MUST" means this requirement must already be satisfied, | |
299 | * otherwise 'max_vq' couldn't itself be enabled. | |
300 | * | |
301 | * [**] Not testable with the QMP interface, only with the command line. | |
302 | */ | |
303 | ||
304 | /* max_vq := 8 */ | |
305 | assert_sve_vls(qts, cpu_type, 0x8b, "{ 'sve1024': true }"); | |
306 | ||
307 | /* max_vq := 8, vq < max_vq, !power-of-two(vq) */ | |
308 | assert_sve_vls(qts, cpu_type, 0x8f, | |
309 | "{ 'sve1024': true, 'sve384': true }"); | |
310 | assert_sve_vls(qts, cpu_type, 0x8b, | |
311 | "{ 'sve1024': true, 'sve384': false }"); | |
312 | ||
313 | /* max_vq := 8, vq < max_vq, power-of-two(vq) */ | |
314 | assert_sve_vls(qts, cpu_type, 0x8b, | |
315 | "{ 'sve1024': true, 'sve256': true }"); | |
316 | assert_error(qts, cpu_type, "cannot disable sve256", | |
317 | "{ 'sve1024': true, 'sve256': false }"); | |
318 | ||
319 | /* max_vq := 3, vq > max_vq, !all-power-of-two(< vq) */ | |
320 | assert_error(qts, cpu_type, "cannot disable sve512", | |
321 | "{ 'sve384': true, 'sve512': false, 'sve640': true }"); | |
322 | ||
323 | /* | |
324 | * We can disable power-of-two vector lengths when all larger lengths | |
325 | * are also disabled. We only need to disable the power-of-two length, | |
326 | * as all non-enabled larger lengths will then be auto-disabled. | |
327 | */ | |
328 | assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve512': false }"); | |
329 | ||
330 | /* max_vq := 3, vq > max_vq, all-power-of-two(< vq) */ | |
331 | assert_sve_vls(qts, cpu_type, 0x1f, | |
332 | "{ 'sve384': true, 'sve512': true, 'sve640': true }"); | |
333 | assert_sve_vls(qts, cpu_type, 0xf, | |
334 | "{ 'sve384': true, 'sve512': true, 'sve640': false }"); | |
335 | } | |
336 | ||
337 | static void sve_tests_sve_max_vq_8(const void *data) | |
338 | { | |
339 | QTestState *qts; | |
340 | ||
341 | qts = qtest_init(MACHINE "-cpu max,sve-max-vq=8"); | |
342 | ||
343 | assert_sve_vls(qts, "max", BIT_ULL(8) - 1, NULL); | |
344 | ||
345 | /* | |
346 | * Disabling the max-vq set by sve-max-vq is not allowed, but | |
347 | * of course enabling it is OK. | |
348 | */ | |
349 | assert_error(qts, "max", "cannot disable sve1024", "{ 'sve1024': false }"); | |
350 | assert_sve_vls(qts, "max", 0xff, "{ 'sve1024': true }"); | |
351 | ||
352 | /* | |
353 | * Enabling anything larger than max-vq set by sve-max-vq is not | |
354 | * allowed, but of course disabling everything larger is OK. | |
355 | */ | |
356 | assert_error(qts, "max", "cannot enable sve1152", "{ 'sve1152': true }"); | |
357 | assert_sve_vls(qts, "max", 0xff, "{ 'sve1152': false }"); | |
358 | ||
359 | /* | |
360 | * We can enable/disable non power-of-two lengths smaller than the | |
361 | * max-vq set by sve-max-vq, but, while we can enable power-of-two | |
362 | * lengths, we can't disable them. | |
363 | */ | |
364 | assert_sve_vls(qts, "max", 0xff, "{ 'sve384': true }"); | |
365 | assert_sve_vls(qts, "max", 0xfb, "{ 'sve384': false }"); | |
366 | assert_sve_vls(qts, "max", 0xff, "{ 'sve256': true }"); | |
367 | assert_error(qts, "max", "cannot disable sve256", "{ 'sve256': false }"); | |
368 | ||
369 | qtest_quit(qts); | |
370 | } | |
371 | ||
372 | static void sve_tests_sve_off(const void *data) | |
373 | { | |
374 | QTestState *qts; | |
375 | ||
376 | qts = qtest_init(MACHINE "-cpu max,sve=off"); | |
377 | ||
378 | /* SVE is off, so the map should be empty. */ | |
379 | assert_sve_vls(qts, "max", 0, NULL); | |
380 | ||
381 | /* The map stays empty even if we turn lengths off. */ | |
382 | assert_sve_vls(qts, "max", 0, "{ 'sve128': false }"); | |
383 | ||
384 | /* It's an error to enable lengths when SVE is off. */ | |
385 | assert_error(qts, "max", "cannot enable sve128", "{ 'sve128': true }"); | |
386 | ||
387 | /* With SVE re-enabled we should get all vector lengths enabled. */ | |
388 | assert_sve_vls(qts, "max", BIT_ULL(SVE_MAX_VQ) - 1, "{ 'sve': true }"); | |
389 | ||
390 | /* Or enable SVE with just specific vector lengths. */ | |
391 | assert_sve_vls(qts, "max", 0x3, | |
392 | "{ 'sve': true, 'sve128': true, 'sve256': true }"); | |
393 | ||
394 | qtest_quit(qts); | |
395 | } | |
396 | ||
6fa8a379 AJ |
397 | static void sve_tests_sve_off_kvm(const void *data) |
398 | { | |
399 | QTestState *qts; | |
400 | ||
401 | qts = qtest_init(MACHINE_KVM "-cpu max,sve=off"); | |
402 | ||
403 | /* | |
404 | * We don't know if this host supports SVE so we don't | |
405 | * attempt to test enabling anything. We only test that | |
406 | * everything is disabled (as it should be with sve=off) | |
407 | * and that using sve<N>=off to explicitly disable vector | |
408 | * lengths is OK too. | |
409 | */ | |
410 | assert_sve_vls(qts, "max", 0, NULL); | |
411 | assert_sve_vls(qts, "max", 0, "{ 'sve128': false }"); | |
412 | ||
413 | qtest_quit(qts); | |
414 | } | |
415 | ||
eb94284d RH |
416 | static void pauth_tests_default(QTestState *qts, const char *cpu_type) |
417 | { | |
418 | assert_has_feature_enabled(qts, cpu_type, "pauth"); | |
419 | assert_has_feature_disabled(qts, cpu_type, "pauth-impdef"); | |
420 | assert_set_feature(qts, cpu_type, "pauth", false); | |
421 | assert_set_feature(qts, cpu_type, "pauth", true); | |
422 | assert_set_feature(qts, cpu_type, "pauth-impdef", true); | |
423 | assert_set_feature(qts, cpu_type, "pauth-impdef", false); | |
424 | assert_error(qts, cpu_type, "cannot enable pauth-impdef without pauth", | |
425 | "{ 'pauth': false, 'pauth-impdef': true }"); | |
426 | } | |
427 | ||
bd31b751 AJ |
428 | static void test_query_cpu_model_expansion(const void *data) |
429 | { | |
430 | QTestState *qts; | |
431 | ||
432 | qts = qtest_init(MACHINE "-cpu max"); | |
433 | ||
434 | /* Test common query-cpu-model-expansion input validation */ | |
435 | assert_type_full(qts); | |
436 | assert_bad_props(qts, "max"); | |
437 | assert_error(qts, "foo", "The CPU type 'foo' is not a recognized " | |
438 | "ARM CPU type", NULL); | |
439 | assert_error(qts, "max", "Parameter 'not-a-prop' is unexpected", | |
440 | "{ 'not-a-prop': false }"); | |
441 | assert_error(qts, "host", "The CPU type 'host' requires KVM", NULL); | |
442 | ||
443 | /* Test expected feature presence/absence for some cpu types */ | |
789a35ef | 444 | assert_has_feature_enabled(qts, "cortex-a15", "pmu"); |
bd31b751 AJ |
445 | assert_has_not_feature(qts, "cortex-a15", "aarch64"); |
446 | ||
92a70997 AJ |
447 | /* Enabling and disabling pmu should always work. */ |
448 | assert_has_feature_enabled(qts, "max", "pmu"); | |
449 | assert_set_feature(qts, "max", "pmu", false); | |
450 | assert_set_feature(qts, "max", "pmu", true); | |
451 | ||
dea101a1 | 452 | assert_has_not_feature(qts, "max", "kvm-no-adjvtime"); |
68970d1e | 453 | assert_has_not_feature(qts, "max", "kvm-steal-time"); |
dea101a1 | 454 | |
bd31b751 | 455 | if (g_str_equal(qtest_get_arch(), "aarch64")) { |
789a35ef AJ |
456 | assert_has_feature_enabled(qts, "max", "aarch64"); |
457 | assert_has_feature_enabled(qts, "max", "sve"); | |
458 | assert_has_feature_enabled(qts, "max", "sve128"); | |
459 | assert_has_feature_enabled(qts, "cortex-a57", "pmu"); | |
460 | assert_has_feature_enabled(qts, "cortex-a57", "aarch64"); | |
bd31b751 | 461 | |
499243e1 SI |
462 | assert_has_feature_enabled(qts, "a64fx", "pmu"); |
463 | assert_has_feature_enabled(qts, "a64fx", "aarch64"); | |
464 | /* | |
465 | * A64FX does not support any other vector lengths besides those | |
466 | * that are enabled by default(128bit, 256bits, 512bit). | |
467 | */ | |
468 | assert_has_feature_enabled(qts, "a64fx", "sve"); | |
469 | assert_sve_vls(qts, "a64fx", 0xb, NULL); | |
470 | assert_error(qts, "a64fx", "cannot enable sve384", | |
471 | "{ 'sve384': true }"); | |
472 | assert_error(qts, "a64fx", "cannot enable sve640", | |
473 | "{ 'sve640': true }"); | |
474 | ||
0df9142d | 475 | sve_tests_default(qts, "max"); |
eb94284d | 476 | pauth_tests_default(qts, "max"); |
0df9142d | 477 | |
bd31b751 AJ |
478 | /* Test that features that depend on KVM generate errors without. */ |
479 | assert_error(qts, "max", | |
480 | "'aarch64' feature cannot be disabled " | |
481 | "unless KVM is enabled and 32-bit EL1 " | |
482 | "is supported", | |
483 | "{ 'aarch64': false }"); | |
484 | } | |
485 | ||
486 | qtest_quit(qts); | |
487 | } | |
488 | ||
489 | static void test_query_cpu_model_expansion_kvm(const void *data) | |
490 | { | |
491 | QTestState *qts; | |
492 | ||
493 | qts = qtest_init(MACHINE_KVM "-cpu max"); | |
494 | ||
92a70997 | 495 | /* Enabling and disabling kvm-no-adjvtime should always work. */ |
dea101a1 | 496 | assert_has_feature_disabled(qts, "host", "kvm-no-adjvtime"); |
92a70997 AJ |
497 | assert_set_feature(qts, "host", "kvm-no-adjvtime", true); |
498 | assert_set_feature(qts, "host", "kvm-no-adjvtime", false); | |
dea101a1 | 499 | |
bd31b751 | 500 | if (g_str_equal(qtest_get_arch(), "aarch64")) { |
68970d1e | 501 | bool kvm_supports_steal_time; |
6fa8a379 AJ |
502 | bool kvm_supports_sve; |
503 | char max_name[8], name[8]; | |
504 | uint32_t max_vq, vq; | |
505 | uint64_t vls; | |
506 | QDict *resp; | |
507 | char *error; | |
508 | ||
68970d1e AJ |
509 | assert_error(qts, "cortex-a15", |
510 | "We cannot guarantee the CPU type 'cortex-a15' works " | |
511 | "with KVM on this host", NULL); | |
512 | ||
789a35ef | 513 | assert_has_feature_enabled(qts, "host", "aarch64"); |
92a70997 AJ |
514 | |
515 | /* Enabling and disabling pmu should always work. */ | |
789a35ef | 516 | assert_has_feature_enabled(qts, "host", "pmu"); |
92a70997 AJ |
517 | assert_set_feature(qts, "host", "pmu", false); |
518 | assert_set_feature(qts, "host", "pmu", true); | |
bd31b751 | 519 | |
68970d1e AJ |
520 | /* |
521 | * Some features would be enabled by default, but they're disabled | |
522 | * because this instance of KVM doesn't support them. Test that the | |
523 | * features are present, and, when enabled, issue further tests. | |
524 | */ | |
525 | assert_has_feature(qts, "host", "kvm-steal-time"); | |
87014c6b | 526 | assert_has_feature(qts, "host", "sve"); |
68970d1e | 527 | |
87014c6b | 528 | resp = do_query_no_props(qts, "host"); |
68970d1e | 529 | kvm_supports_steal_time = resp_get_feature(resp, "kvm-steal-time"); |
6fa8a379 AJ |
530 | kvm_supports_sve = resp_get_feature(resp, "sve"); |
531 | vls = resp_get_sve_vls(resp); | |
532 | qobject_unref(resp); | |
533 | ||
68970d1e AJ |
534 | if (kvm_supports_steal_time) { |
535 | /* If we have steal-time then we should be able to toggle it. */ | |
536 | assert_set_feature(qts, "host", "kvm-steal-time", false); | |
537 | assert_set_feature(qts, "host", "kvm-steal-time", true); | |
538 | } | |
539 | ||
6fa8a379 AJ |
540 | if (kvm_supports_sve) { |
541 | g_assert(vls != 0); | |
542 | max_vq = 64 - __builtin_clzll(vls); | |
3dc05792 | 543 | sprintf(max_name, "sve%u", max_vq * 128); |
6fa8a379 AJ |
544 | |
545 | /* Enabling a supported length is of course fine. */ | |
87014c6b | 546 | assert_sve_vls(qts, "host", vls, "{ %s: true }", max_name); |
6fa8a379 AJ |
547 | |
548 | /* Get the next supported length smaller than max-vq. */ | |
549 | vq = 64 - __builtin_clzll(vls & ~BIT_ULL(max_vq - 1)); | |
550 | if (vq) { | |
551 | /* | |
552 | * We have at least one length smaller than max-vq, | |
553 | * so we can disable max-vq. | |
554 | */ | |
87014c6b | 555 | assert_sve_vls(qts, "host", (vls & ~BIT_ULL(max_vq - 1)), |
6fa8a379 AJ |
556 | "{ %s: false }", max_name); |
557 | ||
558 | /* | |
559 | * Smaller, supported vector lengths cannot be disabled | |
560 | * unless all larger, supported vector lengths are also | |
561 | * disabled. | |
562 | */ | |
3dc05792 | 563 | sprintf(name, "sve%u", vq * 128); |
6fa8a379 | 564 | error = g_strdup_printf("cannot disable %s", name); |
87014c6b | 565 | assert_error(qts, "host", error, |
6fa8a379 AJ |
566 | "{ %s: true, %s: false }", |
567 | max_name, name); | |
568 | g_free(error); | |
569 | } | |
570 | ||
571 | /* | |
572 | * The smallest, supported vector length is required, because | |
573 | * we need at least one vector length enabled. | |
574 | */ | |
575 | vq = __builtin_ffsll(vls); | |
3dc05792 | 576 | sprintf(name, "sve%u", vq * 128); |
6fa8a379 | 577 | error = g_strdup_printf("cannot disable %s", name); |
87014c6b | 578 | assert_error(qts, "host", error, "{ %s: false }", name); |
6fa8a379 AJ |
579 | g_free(error); |
580 | ||
581 | /* Get an unsupported length. */ | |
582 | for (vq = 1; vq <= max_vq; ++vq) { | |
583 | if (!(vls & BIT_ULL(vq - 1))) { | |
584 | break; | |
585 | } | |
586 | } | |
587 | if (vq <= SVE_MAX_VQ) { | |
3dc05792 | 588 | sprintf(name, "sve%u", vq * 128); |
6fa8a379 | 589 | error = g_strdup_printf("cannot enable %s", name); |
87014c6b | 590 | assert_error(qts, "host", error, "{ %s: true }", name); |
6fa8a379 AJ |
591 | g_free(error); |
592 | } | |
593 | } else { | |
594 | g_assert(vls == 0); | |
595 | } | |
bd31b751 AJ |
596 | } else { |
597 | assert_has_not_feature(qts, "host", "aarch64"); | |
598 | assert_has_not_feature(qts, "host", "pmu"); | |
87014c6b | 599 | assert_has_not_feature(qts, "host", "sve"); |
68970d1e | 600 | assert_has_not_feature(qts, "host", "kvm-steal-time"); |
bd31b751 AJ |
601 | } |
602 | ||
603 | qtest_quit(qts); | |
604 | } | |
605 | ||
606 | int main(int argc, char **argv) | |
607 | { | |
608 | g_test_init(&argc, &argv, NULL); | |
609 | ||
610 | qtest_add_data_func("/arm/query-cpu-model-expansion", | |
611 | NULL, test_query_cpu_model_expansion); | |
612 | ||
613 | /* | |
614 | * For now we only run KVM specific tests with AArch64 QEMU in | |
615 | * order avoid attempting to run an AArch32 QEMU with KVM on | |
616 | * AArch64 hosts. That won't work and isn't easy to detect. | |
617 | */ | |
07e6ed2c IM |
618 | if (g_str_equal(qtest_get_arch(), "aarch64") && qtest_has_accel("kvm")) { |
619 | /* | |
620 | * This tests target the 'host' CPU type, so register it only if | |
621 | * KVM is available. | |
622 | */ | |
bd31b751 AJ |
623 | qtest_add_data_func("/arm/kvm/query-cpu-model-expansion", |
624 | NULL, test_query_cpu_model_expansion_kvm); | |
625 | } | |
626 | ||
0df9142d AJ |
627 | if (g_str_equal(qtest_get_arch(), "aarch64")) { |
628 | qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-max-vq-8", | |
629 | NULL, sve_tests_sve_max_vq_8); | |
630 | qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-off", | |
631 | NULL, sve_tests_sve_off); | |
6fa8a379 AJ |
632 | qtest_add_data_func("/arm/kvm/query-cpu-model-expansion/sve-off", |
633 | NULL, sve_tests_sve_off_kvm); | |
0df9142d AJ |
634 | } |
635 | ||
bd31b751 AJ |
636 | return g_test_run(); |
637 | } |