2 * Arm CPU feature test cases
4 * Copyright (c) 2019 Red Hat Inc.
6 * Andrew Jones <drjones@redhat.com>
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.
11 #include "qemu/osdep.h"
12 #include "qemu/bitops.h"
13 #include "libqos/libqtest.h"
14 #include "qapi/qmp/qdict.h"
15 #include "qapi/qmp/qjson.h"
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.
23 #define MACHINE "-machine virt,gic-version=max -accel tcg "
24 #define MACHINE_KVM "-machine virt,gic-version=max -accel kvm -accel tcg "
25 #define QUERY_HEAD "{ 'execute': 'query-cpu-model-expansion', " \
26 " 'arguments': { 'type': 'full', "
27 #define QUERY_TAIL "}}"
29 static bool kvm_enabled(QTestState
*qts
)
34 resp
= qtest_qmp(qts
, "{ 'execute': 'query-kvm' }");
35 g_assert(qdict_haskey(resp
, "return"));
36 qdict
= qdict_get_qdict(resp
, "return");
37 g_assert(qdict_haskey(qdict
, "enabled"));
38 enabled
= qdict_get_bool(qdict
, "enabled");
44 static QDict
*do_query_no_props(QTestState
*qts
, const char *cpu_type
)
46 return qtest_qmp(qts
, QUERY_HEAD
"'model': { 'name': %s }"
47 QUERY_TAIL
, cpu_type
);
50 static QDict
*do_query(QTestState
*qts
, const char *cpu_type
,
60 args
= qdict_from_vjsonf_nofail(fmt
, ap
);
63 resp
= qtest_qmp(qts
, QUERY_HEAD
"'model': { 'name': %s, "
65 QUERY_TAIL
, cpu_type
, args
);
67 resp
= do_query_no_props(qts
, cpu_type
);
73 static const char *resp_get_error(QDict
*resp
)
79 qdict
= qdict_get_qdict(resp
, "error");
81 return qdict_get_str(qdict
, "desc");
87 #define assert_error(qts, cpu_type, expected_error, fmt, ...) \
92 _resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__); \
94 _error = resp_get_error(_resp); \
96 g_assert(g_str_equal(_error, expected_error)); \
97 qobject_unref(_resp); \
100 static bool resp_has_props(QDict
*resp
)
106 if (!qdict_haskey(resp
, "return")) {
109 qdict
= qdict_get_qdict(resp
, "return");
111 if (!qdict_haskey(qdict
, "model")) {
114 qdict
= qdict_get_qdict(qdict
, "model");
116 return qdict_haskey(qdict
, "props");
119 static QDict
*resp_get_props(QDict
*resp
)
124 g_assert(resp_has_props(resp
));
126 qdict
= qdict_get_qdict(resp
, "return");
127 qdict
= qdict_get_qdict(qdict
, "model");
128 qdict
= qdict_get_qdict(qdict
, "props");
133 static bool resp_get_feature(QDict
*resp
, const char *feature
)
138 g_assert(resp_has_props(resp
));
139 props
= resp_get_props(resp
);
140 g_assert(qdict_get(props
, feature
));
141 return qdict_get_bool(props
, feature
);
144 #define assert_has_feature(qts, cpu_type, feature) \
146 QDict *_resp = do_query_no_props(qts, cpu_type); \
148 g_assert(resp_has_props(_resp)); \
149 g_assert(qdict_get(resp_get_props(_resp), feature)); \
150 qobject_unref(_resp); \
153 #define assert_has_not_feature(qts, cpu_type, feature) \
155 QDict *_resp = do_query_no_props(qts, cpu_type); \
157 g_assert(!resp_has_props(_resp) || \
158 !qdict_get(resp_get_props(_resp), feature)); \
159 qobject_unref(_resp); \
162 #define resp_assert_feature(resp, feature, expected_value) \
167 g_assert(resp_has_props(_resp)); \
168 _props = resp_get_props(_resp); \
169 g_assert(qdict_get(_props, feature)); \
170 g_assert(qdict_get_bool(_props, feature) == (expected_value)); \
173 #define assert_feature(qts, cpu_type, feature, expected_value) \
177 _resp = do_query_no_props(qts, cpu_type); \
179 resp_assert_feature(_resp, feature, expected_value); \
180 qobject_unref(_resp); \
183 #define assert_set_feature(qts, cpu_type, feature, value) \
185 const char *_fmt = (value) ? "{ %s: true }" : "{ %s: false }"; \
188 _resp = do_query(qts, cpu_type, _fmt, feature); \
190 resp_assert_feature(_resp, feature, value); \
191 qobject_unref(_resp); \
194 #define assert_has_feature_enabled(qts, cpu_type, feature) \
195 assert_feature(qts, cpu_type, feature, true)
197 #define assert_has_feature_disabled(qts, cpu_type, feature) \
198 assert_feature(qts, cpu_type, feature, false)
200 static void assert_type_full(QTestState
*qts
)
205 resp
= qtest_qmp(qts
, "{ 'execute': 'query-cpu-model-expansion', "
206 "'arguments': { 'type': 'static', "
207 "'model': { 'name': 'foo' }}}");
209 error
= resp_get_error(resp
);
211 g_assert(g_str_equal(error
,
212 "The requested expansion type is not supported"));
216 static void assert_bad_props(QTestState
*qts
, const char *cpu_type
)
221 resp
= qtest_qmp(qts
, "{ 'execute': 'query-cpu-model-expansion', "
222 "'arguments': { 'type': 'full', "
223 "'model': { 'name': %s, "
224 "'props': false }}}",
227 error
= resp_get_error(resp
);
229 g_assert(g_str_equal(error
,
230 "Invalid parameter type for 'props', expected: dict"));
234 static uint64_t resp_get_sve_vls(QDict
*resp
)
242 g_assert(resp_has_props(resp
));
244 props
= resp_get_props(resp
);
246 for (e
= qdict_first(props
); e
; e
= qdict_next(props
, e
)) {
247 if (strlen(e
->key
) > 3 && !strncmp(e
->key
, "sve", 3) &&
248 g_ascii_isdigit(e
->key
[3])) {
252 bits
= g_ascii_strtoll(&e
->key
[3], &endptr
, 10);
253 if (!bits
|| *endptr
!= '\0') {
257 if (qdict_get_bool(props
, e
->key
)) {
258 vls
|= BIT_ULL((bits
/ 128) - 1);
264 g_assert(n
== SVE_MAX_VQ
);
269 #define assert_sve_vls(qts, cpu_type, expected_vls, fmt, ...) \
271 QDict *_resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__); \
273 g_assert(resp_has_props(_resp)); \
274 g_assert(resp_get_sve_vls(_resp) == expected_vls); \
275 qobject_unref(_resp); \
278 static void sve_tests_default(QTestState
*qts
, const char *cpu_type
)
281 * With no sve-max-vq or sve<N> properties on the command line
282 * the default is to have all vector lengths enabled. This also
283 * tests that 'sve' is 'on' by default.
285 assert_sve_vls(qts
, cpu_type
, BIT_ULL(SVE_MAX_VQ
) - 1, NULL
);
287 /* With SVE off, all vector lengths should also be off. */
288 assert_sve_vls(qts
, cpu_type
, 0, "{ 'sve': false }");
290 /* With SVE on, we must have at least one vector length enabled. */
291 assert_error(qts
, cpu_type
, "cannot disable sve128", "{ 'sve128': false }");
293 /* Basic enable/disable tests. */
294 assert_sve_vls(qts
, cpu_type
, 0x7, "{ 'sve384': true }");
295 assert_sve_vls(qts
, cpu_type
, ((BIT_ULL(SVE_MAX_VQ
) - 1) & ~BIT_ULL(2)),
296 "{ 'sve384': false }");
299 * ---------------------------------------------------------------------
300 * power-of-two(vq) all-power- can can
301 * of-two(< vq) enable disable
302 * ---------------------------------------------------------------------
303 * vq < max_vq no MUST* yes yes
304 * vq < max_vq yes MUST* yes no
305 * ---------------------------------------------------------------------
306 * vq == max_vq n/a MUST* yes** yes**
307 * ---------------------------------------------------------------------
308 * vq > max_vq n/a no no yes
309 * vq > max_vq n/a yes yes yes
310 * ---------------------------------------------------------------------
312 * [*] "MUST" means this requirement must already be satisfied,
313 * otherwise 'max_vq' couldn't itself be enabled.
315 * [**] Not testable with the QMP interface, only with the command line.
319 assert_sve_vls(qts
, cpu_type
, 0x8b, "{ 'sve1024': true }");
321 /* max_vq := 8, vq < max_vq, !power-of-two(vq) */
322 assert_sve_vls(qts
, cpu_type
, 0x8f,
323 "{ 'sve1024': true, 'sve384': true }");
324 assert_sve_vls(qts
, cpu_type
, 0x8b,
325 "{ 'sve1024': true, 'sve384': false }");
327 /* max_vq := 8, vq < max_vq, power-of-two(vq) */
328 assert_sve_vls(qts
, cpu_type
, 0x8b,
329 "{ 'sve1024': true, 'sve256': true }");
330 assert_error(qts
, cpu_type
, "cannot disable sve256",
331 "{ 'sve1024': true, 'sve256': false }");
333 /* max_vq := 3, vq > max_vq, !all-power-of-two(< vq) */
334 assert_error(qts
, cpu_type
, "cannot disable sve512",
335 "{ 'sve384': true, 'sve512': false, 'sve640': true }");
338 * We can disable power-of-two vector lengths when all larger lengths
339 * are also disabled. We only need to disable the power-of-two length,
340 * as all non-enabled larger lengths will then be auto-disabled.
342 assert_sve_vls(qts
, cpu_type
, 0x7, "{ 'sve512': false }");
344 /* max_vq := 3, vq > max_vq, all-power-of-two(< vq) */
345 assert_sve_vls(qts
, cpu_type
, 0x1f,
346 "{ 'sve384': true, 'sve512': true, 'sve640': true }");
347 assert_sve_vls(qts
, cpu_type
, 0xf,
348 "{ 'sve384': true, 'sve512': true, 'sve640': false }");
351 static void sve_tests_sve_max_vq_8(const void *data
)
355 qts
= qtest_init(MACHINE
"-cpu max,sve-max-vq=8");
357 assert_sve_vls(qts
, "max", BIT_ULL(8) - 1, NULL
);
360 * Disabling the max-vq set by sve-max-vq is not allowed, but
361 * of course enabling it is OK.
363 assert_error(qts
, "max", "cannot disable sve1024", "{ 'sve1024': false }");
364 assert_sve_vls(qts
, "max", 0xff, "{ 'sve1024': true }");
367 * Enabling anything larger than max-vq set by sve-max-vq is not
368 * allowed, but of course disabling everything larger is OK.
370 assert_error(qts
, "max", "cannot enable sve1152", "{ 'sve1152': true }");
371 assert_sve_vls(qts
, "max", 0xff, "{ 'sve1152': false }");
374 * We can enable/disable non power-of-two lengths smaller than the
375 * max-vq set by sve-max-vq, but, while we can enable power-of-two
376 * lengths, we can't disable them.
378 assert_sve_vls(qts
, "max", 0xff, "{ 'sve384': true }");
379 assert_sve_vls(qts
, "max", 0xfb, "{ 'sve384': false }");
380 assert_sve_vls(qts
, "max", 0xff, "{ 'sve256': true }");
381 assert_error(qts
, "max", "cannot disable sve256", "{ 'sve256': false }");
386 static void sve_tests_sve_off(const void *data
)
390 qts
= qtest_init(MACHINE
"-cpu max,sve=off");
392 /* SVE is off, so the map should be empty. */
393 assert_sve_vls(qts
, "max", 0, NULL
);
395 /* The map stays empty even if we turn lengths off. */
396 assert_sve_vls(qts
, "max", 0, "{ 'sve128': false }");
398 /* It's an error to enable lengths when SVE is off. */
399 assert_error(qts
, "max", "cannot enable sve128", "{ 'sve128': true }");
401 /* With SVE re-enabled we should get all vector lengths enabled. */
402 assert_sve_vls(qts
, "max", BIT_ULL(SVE_MAX_VQ
) - 1, "{ 'sve': true }");
404 /* Or enable SVE with just specific vector lengths. */
405 assert_sve_vls(qts
, "max", 0x3,
406 "{ 'sve': true, 'sve128': true, 'sve256': true }");
411 static void sve_tests_sve_off_kvm(const void *data
)
415 qts
= qtest_init(MACHINE_KVM
"-cpu max,sve=off");
418 * We don't know if this host supports SVE so we don't
419 * attempt to test enabling anything. We only test that
420 * everything is disabled (as it should be with sve=off)
421 * and that using sve<N>=off to explicitly disable vector
424 assert_sve_vls(qts
, "max", 0, NULL
);
425 assert_sve_vls(qts
, "max", 0, "{ 'sve128': false }");
430 static void pauth_tests_default(QTestState
*qts
, const char *cpu_type
)
432 assert_has_feature_enabled(qts
, cpu_type
, "pauth");
433 assert_has_feature_disabled(qts
, cpu_type
, "pauth-impdef");
434 assert_set_feature(qts
, cpu_type
, "pauth", false);
435 assert_set_feature(qts
, cpu_type
, "pauth", true);
436 assert_set_feature(qts
, cpu_type
, "pauth-impdef", true);
437 assert_set_feature(qts
, cpu_type
, "pauth-impdef", false);
438 assert_error(qts
, cpu_type
, "cannot enable pauth-impdef without pauth",
439 "{ 'pauth': false, 'pauth-impdef': true }");
442 static void test_query_cpu_model_expansion(const void *data
)
446 qts
= qtest_init(MACHINE
"-cpu max");
448 /* Test common query-cpu-model-expansion input validation */
449 assert_type_full(qts
);
450 assert_bad_props(qts
, "max");
451 assert_error(qts
, "foo", "The CPU type 'foo' is not a recognized "
452 "ARM CPU type", NULL
);
453 assert_error(qts
, "max", "Parameter 'not-a-prop' is unexpected",
454 "{ 'not-a-prop': false }");
455 assert_error(qts
, "host", "The CPU type 'host' requires KVM", NULL
);
457 /* Test expected feature presence/absence for some cpu types */
458 assert_has_feature_enabled(qts
, "cortex-a15", "pmu");
459 assert_has_not_feature(qts
, "cortex-a15", "aarch64");
461 /* Enabling and disabling pmu should always work. */
462 assert_has_feature_enabled(qts
, "max", "pmu");
463 assert_set_feature(qts
, "max", "pmu", false);
464 assert_set_feature(qts
, "max", "pmu", true);
466 assert_has_not_feature(qts
, "max", "kvm-no-adjvtime");
467 assert_has_not_feature(qts
, "max", "kvm-steal-time");
469 if (g_str_equal(qtest_get_arch(), "aarch64")) {
470 assert_has_feature_enabled(qts
, "max", "aarch64");
471 assert_has_feature_enabled(qts
, "max", "sve");
472 assert_has_feature_enabled(qts
, "max", "sve128");
473 assert_has_feature_enabled(qts
, "cortex-a57", "pmu");
474 assert_has_feature_enabled(qts
, "cortex-a57", "aarch64");
476 assert_has_feature_enabled(qts
, "a64fx", "pmu");
477 assert_has_feature_enabled(qts
, "a64fx", "aarch64");
479 * A64FX does not support any other vector lengths besides those
480 * that are enabled by default(128bit, 256bits, 512bit).
482 assert_has_feature_enabled(qts
, "a64fx", "sve");
483 assert_sve_vls(qts
, "a64fx", 0xb, NULL
);
484 assert_error(qts
, "a64fx", "cannot enable sve384",
485 "{ 'sve384': true }");
486 assert_error(qts
, "a64fx", "cannot enable sve640",
487 "{ 'sve640': true }");
489 sve_tests_default(qts
, "max");
490 pauth_tests_default(qts
, "max");
492 /* Test that features that depend on KVM generate errors without. */
493 assert_error(qts
, "max",
494 "'aarch64' feature cannot be disabled "
495 "unless KVM is enabled and 32-bit EL1 "
497 "{ 'aarch64': false }");
503 static void test_query_cpu_model_expansion_kvm(const void *data
)
507 qts
= qtest_init(MACHINE_KVM
"-cpu max");
510 * These tests target the 'host' CPU type, so KVM must be enabled.
512 if (!kvm_enabled(qts
)) {
517 /* Enabling and disabling kvm-no-adjvtime should always work. */
518 assert_has_feature_disabled(qts
, "host", "kvm-no-adjvtime");
519 assert_set_feature(qts
, "host", "kvm-no-adjvtime", true);
520 assert_set_feature(qts
, "host", "kvm-no-adjvtime", false);
522 if (g_str_equal(qtest_get_arch(), "aarch64")) {
523 bool kvm_supports_steal_time
;
524 bool kvm_supports_sve
;
525 char max_name
[8], name
[8];
531 assert_error(qts
, "cortex-a15",
532 "We cannot guarantee the CPU type 'cortex-a15' works "
533 "with KVM on this host", NULL
);
535 assert_has_feature_enabled(qts
, "host", "aarch64");
537 /* Enabling and disabling pmu should always work. */
538 assert_has_feature_enabled(qts
, "host", "pmu");
539 assert_set_feature(qts
, "host", "pmu", false);
540 assert_set_feature(qts
, "host", "pmu", true);
543 * Some features would be enabled by default, but they're disabled
544 * because this instance of KVM doesn't support them. Test that the
545 * features are present, and, when enabled, issue further tests.
547 assert_has_feature(qts
, "host", "kvm-steal-time");
548 assert_has_feature(qts
, "host", "sve");
550 resp
= do_query_no_props(qts
, "host");
551 kvm_supports_steal_time
= resp_get_feature(resp
, "kvm-steal-time");
552 kvm_supports_sve
= resp_get_feature(resp
, "sve");
553 vls
= resp_get_sve_vls(resp
);
556 if (kvm_supports_steal_time
) {
557 /* If we have steal-time then we should be able to toggle it. */
558 assert_set_feature(qts
, "host", "kvm-steal-time", false);
559 assert_set_feature(qts
, "host", "kvm-steal-time", true);
562 if (kvm_supports_sve
) {
564 max_vq
= 64 - __builtin_clzll(vls
);
565 sprintf(max_name
, "sve%u", max_vq
* 128);
567 /* Enabling a supported length is of course fine. */
568 assert_sve_vls(qts
, "host", vls
, "{ %s: true }", max_name
);
570 /* Get the next supported length smaller than max-vq. */
571 vq
= 64 - __builtin_clzll(vls
& ~BIT_ULL(max_vq
- 1));
574 * We have at least one length smaller than max-vq,
575 * so we can disable max-vq.
577 assert_sve_vls(qts
, "host", (vls
& ~BIT_ULL(max_vq
- 1)),
578 "{ %s: false }", max_name
);
581 * Smaller, supported vector lengths cannot be disabled
582 * unless all larger, supported vector lengths are also
585 sprintf(name
, "sve%u", vq
* 128);
586 error
= g_strdup_printf("cannot disable %s", name
);
587 assert_error(qts
, "host", error
,
588 "{ %s: true, %s: false }",
594 * The smallest, supported vector length is required, because
595 * we need at least one vector length enabled.
597 vq
= __builtin_ffsll(vls
);
598 sprintf(name
, "sve%u", vq
* 128);
599 error
= g_strdup_printf("cannot disable %s", name
);
600 assert_error(qts
, "host", error
, "{ %s: false }", name
);
603 /* Get an unsupported length. */
604 for (vq
= 1; vq
<= max_vq
; ++vq
) {
605 if (!(vls
& BIT_ULL(vq
- 1))) {
609 if (vq
<= SVE_MAX_VQ
) {
610 sprintf(name
, "sve%u", vq
* 128);
611 error
= g_strdup_printf("cannot enable %s", name
);
612 assert_error(qts
, "host", error
, "{ %s: true }", name
);
619 assert_has_not_feature(qts
, "host", "aarch64");
620 assert_has_not_feature(qts
, "host", "pmu");
621 assert_has_not_feature(qts
, "host", "sve");
622 assert_has_not_feature(qts
, "host", "kvm-steal-time");
628 int main(int argc
, char **argv
)
630 g_test_init(&argc
, &argv
, NULL
);
632 qtest_add_data_func("/arm/query-cpu-model-expansion",
633 NULL
, test_query_cpu_model_expansion
);
636 * For now we only run KVM specific tests with AArch64 QEMU in
637 * order avoid attempting to run an AArch32 QEMU with KVM on
638 * AArch64 hosts. That won't work and isn't easy to detect.
640 if (g_str_equal(qtest_get_arch(), "aarch64")) {
641 qtest_add_data_func("/arm/kvm/query-cpu-model-expansion",
642 NULL
, test_query_cpu_model_expansion_kvm
);
645 if (g_str_equal(qtest_get_arch(), "aarch64")) {
646 qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-max-vq-8",
647 NULL
, sve_tests_sve_max_vq_8
);
648 qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-off",
649 NULL
, sve_tests_sve_off
);
650 qtest_add_data_func("/arm/kvm/query-cpu-model-expansion/sve-off",
651 NULL
, sve_tests_sve_off_kvm
);