xref: /openbmc/qemu/tests/qtest/arm-cpu-features.c (revision 71328d82)
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"
12 #include "qemu/bitops.h"
13 #include "libqtest.h"
14 #include "qapi/qmp/qdict.h"
15 #include "qapi/qmp/qjson.h"
16 
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 
23 #define MACHINE     "-machine virt,gic-version=max -accel tcg "
24 #define MACHINE_KVM "-machine virt,gic-version=max -accel kvm "
25 #define QUERY_HEAD  "{ 'execute': 'query-cpu-model-expansion', " \
26                     "  'arguments': { 'type': 'full', "
27 #define QUERY_TAIL  "}}"
28 
do_query_no_props(QTestState * qts,const char * cpu_type)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 
35 G_GNUC_PRINTF(3, 4)
do_query(QTestState * qts,const char * cpu_type,const char * fmt,...)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 
resp_get_error(QDict * resp)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_cmpstr(_error, ==, expected_error);                       \
83     qobject_unref(_resp);                                              \
84 })
85 
resp_has_props(QDict * resp)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 
resp_get_props(QDict * resp)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 
resp_get_feature(QDict * resp,const char * feature)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 
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 
148 #define resp_assert_feature(resp, feature, expected_value)             \
149 ({                                                                     \
150     QDict *_props;                                                     \
151                                                                        \
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));     \
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);                        \
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 
assert_type_full(QTestState * qts)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_cmpstr(error, ==,
198                     "The requested expansion type is not supported");
199     qobject_unref(resp);
200 }
201 
assert_bad_props(QTestState * qts,const char * cpu_type)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_cmpstr(error, ==,
216                     "Invalid parameter type for 'model.props',"
217                     " expected: object");
218     qobject_unref(resp);
219 }
220 
resp_get_sve_vls(QDict * resp)221 static uint64_t resp_get_sve_vls(QDict *resp)
222 {
223     QDict *props;
224     const QDictEntry *e;
225     uint64_t vls = 0;
226     int n = 0;
227 
228     g_assert(resp);
229     g_assert(resp_has_props(resp));
230 
231     props = resp_get_props(resp);
232 
233     for (e = qdict_first(props); e; e = qdict_next(props, e)) {
234         if (strlen(e->key) > 3 && !strncmp(e->key, "sve", 3) &&
235             g_ascii_isdigit(e->key[3])) {
236             char *endptr;
237             int bits;
238 
239             bits = g_ascii_strtoll(&e->key[3], &endptr, 10);
240             if (!bits || *endptr != '\0') {
241                 continue;
242             }
243 
244             if (qdict_get_bool(props, e->key)) {
245                 vls |= BIT_ULL((bits / 128) - 1);
246             }
247             ++n;
248         }
249     }
250 
251     g_assert(n == SVE_MAX_VQ);
252 
253     return vls;
254 }
255 
256 #define assert_sve_vls(qts, cpu_type, expected_vls, fmt, ...)          \
257 ({                                                                     \
258     QDict *_resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__);        \
259     g_assert(_resp);                                                   \
260     g_assert(resp_has_props(_resp));                                   \
261     g_assert(resp_get_sve_vls(_resp) == expected_vls);                 \
262     qobject_unref(_resp);                                              \
263 })
264 
sve_tests_default(QTestState * qts,const char * cpu_type)265 static void sve_tests_default(QTestState *qts, const char *cpu_type)
266 {
267     /*
268      * With no sve-max-vq or sve<N> properties on the command line
269      * the default is to have all vector lengths enabled. This also
270      * tests that 'sve' is 'on' by default.
271      */
272     assert_sve_vls(qts, cpu_type, BIT_ULL(SVE_MAX_VQ) - 1, NULL);
273 
274     /* With SVE off, all vector lengths should also be off. */
275     assert_sve_vls(qts, cpu_type, 0, "{ 'sve': false }");
276 
277     /* With SVE on, we must have at least one vector length enabled. */
278     assert_error(qts, cpu_type, "cannot disable sve128", "{ 'sve128': false }");
279 
280     /* Basic enable/disable tests. */
281     assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve384': true }");
282     assert_sve_vls(qts, cpu_type, ((BIT_ULL(SVE_MAX_VQ) - 1) & ~BIT_ULL(2)),
283                    "{ 'sve384': false }");
284 
285     /*
286      * ---------------------------------------------------------------------
287      *               power-of-two(vq)   all-power-            can      can
288      *                                  of-two(< vq)        enable   disable
289      * ---------------------------------------------------------------------
290      * vq < max_vq      no                MUST*              yes      yes
291      * vq < max_vq      yes               MUST*              yes      no
292      * ---------------------------------------------------------------------
293      * vq == max_vq     n/a               MUST*              yes**    yes**
294      * ---------------------------------------------------------------------
295      * vq > max_vq      n/a               no                 no       yes
296      * vq > max_vq      n/a               yes                yes      yes
297      * ---------------------------------------------------------------------
298      *
299      * [*] "MUST" means this requirement must already be satisfied,
300      *     otherwise 'max_vq' couldn't itself be enabled.
301      *
302      * [**] Not testable with the QMP interface, only with the command line.
303      */
304 
305     /* max_vq := 8 */
306     assert_sve_vls(qts, cpu_type, 0x8b, "{ 'sve1024': true }");
307 
308     /* max_vq := 8, vq < max_vq, !power-of-two(vq) */
309     assert_sve_vls(qts, cpu_type, 0x8f,
310                    "{ 'sve1024': true, 'sve384': true }");
311     assert_sve_vls(qts, cpu_type, 0x8b,
312                    "{ 'sve1024': true, 'sve384': false }");
313 
314     /* max_vq := 8, vq < max_vq, power-of-two(vq) */
315     assert_sve_vls(qts, cpu_type, 0x8b,
316                    "{ 'sve1024': true, 'sve256': true }");
317     assert_error(qts, cpu_type, "cannot disable sve256",
318                  "{ 'sve1024': true, 'sve256': false }");
319 
320     /* max_vq := 3, vq > max_vq, !all-power-of-two(< vq) */
321     assert_error(qts, cpu_type, "cannot disable sve512",
322                  "{ 'sve384': true, 'sve512': false, 'sve640': true }");
323 
324     /*
325      * We can disable power-of-two vector lengths when all larger lengths
326      * are also disabled. We only need to disable the power-of-two length,
327      * as all non-enabled larger lengths will then be auto-disabled.
328      */
329     assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve512': false }");
330 
331     /* max_vq := 3, vq > max_vq, all-power-of-two(< vq) */
332     assert_sve_vls(qts, cpu_type, 0x1f,
333                    "{ 'sve384': true, 'sve512': true, 'sve640': true }");
334     assert_sve_vls(qts, cpu_type, 0xf,
335                    "{ 'sve384': true, 'sve512': true, 'sve640': false }");
336 }
337 
sve_tests_sve_max_vq_8(const void * data)338 static void sve_tests_sve_max_vq_8(const void *data)
339 {
340     QTestState *qts;
341 
342     qts = qtest_init(MACHINE "-cpu max,sve-max-vq=8");
343 
344     assert_sve_vls(qts, "max", BIT_ULL(8) - 1, NULL);
345 
346     /*
347      * Disabling the max-vq set by sve-max-vq is not allowed, but
348      * of course enabling it is OK.
349      */
350     assert_error(qts, "max", "cannot disable sve1024", "{ 'sve1024': false }");
351     assert_sve_vls(qts, "max", 0xff, "{ 'sve1024': true }");
352 
353     /*
354      * Enabling anything larger than max-vq set by sve-max-vq is not
355      * allowed, but of course disabling everything larger is OK.
356      */
357     assert_error(qts, "max", "cannot enable sve1152", "{ 'sve1152': true }");
358     assert_sve_vls(qts, "max", 0xff, "{ 'sve1152': false }");
359 
360     /*
361      * We can enable/disable non power-of-two lengths smaller than the
362      * max-vq set by sve-max-vq, but, while we can enable power-of-two
363      * lengths, we can't disable them.
364      */
365     assert_sve_vls(qts, "max", 0xff, "{ 'sve384': true }");
366     assert_sve_vls(qts, "max", 0xfb, "{ 'sve384': false }");
367     assert_sve_vls(qts, "max", 0xff, "{ 'sve256': true }");
368     assert_error(qts, "max", "cannot disable sve256", "{ 'sve256': false }");
369 
370     qtest_quit(qts);
371 }
372 
sve_tests_sve_off(const void * data)373 static void sve_tests_sve_off(const void *data)
374 {
375     QTestState *qts;
376 
377     qts = qtest_init(MACHINE "-cpu max,sve=off");
378 
379     /* SVE is off, so the map should be empty. */
380     assert_sve_vls(qts, "max", 0, NULL);
381 
382     /* The map stays empty even if we turn lengths off. */
383     assert_sve_vls(qts, "max", 0, "{ 'sve128': false }");
384 
385     /* It's an error to enable lengths when SVE is off. */
386     assert_error(qts, "max", "cannot enable sve128", "{ 'sve128': true }");
387 
388     /* With SVE re-enabled we should get all vector lengths enabled. */
389     assert_sve_vls(qts, "max", BIT_ULL(SVE_MAX_VQ) - 1, "{ 'sve': true }");
390 
391     /* Or enable SVE with just specific vector lengths. */
392     assert_sve_vls(qts, "max", 0x3,
393                    "{ 'sve': true, 'sve128': true, 'sve256': true }");
394 
395     qtest_quit(qts);
396 }
397 
sve_tests_sve_off_kvm(const void * data)398 static void sve_tests_sve_off_kvm(const void *data)
399 {
400     QTestState *qts;
401 
402     qts = qtest_init(MACHINE_KVM "-cpu max,sve=off");
403 
404     /*
405      * We don't know if this host supports SVE so we don't
406      * attempt to test enabling anything. We only test that
407      * everything is disabled (as it should be with sve=off)
408      * and that using sve<N>=off to explicitly disable vector
409      * lengths is OK too.
410      */
411     assert_sve_vls(qts, "max", 0, NULL);
412     assert_sve_vls(qts, "max", 0, "{ 'sve128': false }");
413 
414     qtest_quit(qts);
415 }
416 
pauth_tests_default(QTestState * qts,const char * cpu_type)417 static void pauth_tests_default(QTestState *qts, const char *cpu_type)
418 {
419     assert_has_feature_enabled(qts, cpu_type, "pauth");
420     assert_has_feature_disabled(qts, cpu_type, "pauth-impdef");
421     assert_has_feature_disabled(qts, cpu_type, "pauth-qarma3");
422     assert_set_feature(qts, cpu_type, "pauth", false);
423     assert_set_feature(qts, cpu_type, "pauth", true);
424     assert_set_feature(qts, cpu_type, "pauth-impdef", true);
425     assert_set_feature(qts, cpu_type, "pauth-impdef", false);
426     assert_set_feature(qts, cpu_type, "pauth-qarma3", true);
427     assert_set_feature(qts, cpu_type, "pauth-qarma3", false);
428     assert_error(qts, cpu_type,
429                  "cannot enable pauth-impdef or pauth-qarma3 without pauth",
430                  "{ 'pauth': false, 'pauth-impdef': true }");
431     assert_error(qts, cpu_type,
432                  "cannot enable pauth-impdef or pauth-qarma3 without pauth",
433                  "{ 'pauth': false, 'pauth-qarma3': true }");
434     assert_error(qts, cpu_type,
435                  "cannot enable both pauth-impdef and pauth-qarma3",
436                  "{ 'pauth': true, 'pauth-impdef': true, 'pauth-qarma3': true }");
437 }
438 
test_query_cpu_model_expansion(const void * data)439 static void test_query_cpu_model_expansion(const void *data)
440 {
441     QTestState *qts;
442 
443     qts = qtest_init(MACHINE "-cpu max");
444 
445     /* Test common query-cpu-model-expansion input validation */
446     assert_type_full(qts);
447     assert_bad_props(qts, "max");
448     assert_error(qts, "foo", "The CPU type 'foo' is not a recognized "
449                  "ARM CPU type", NULL);
450     assert_error(qts, "max", "Parameter 'model.props.not-a-prop' is unexpected",
451                  "{ 'not-a-prop': false }");
452     assert_error(qts, "host", "The CPU type 'host' requires KVM", NULL);
453 
454     /* Test expected feature presence/absence for some cpu types */
455     assert_has_feature_enabled(qts, "cortex-a15", "pmu");
456     assert_has_not_feature(qts, "cortex-a15", "aarch64");
457 
458     /* Enabling and disabling pmu should always work. */
459     assert_has_feature_enabled(qts, "max", "pmu");
460     assert_set_feature(qts, "max", "pmu", false);
461     assert_set_feature(qts, "max", "pmu", true);
462 
463     assert_has_not_feature(qts, "max", "kvm-no-adjvtime");
464     assert_has_not_feature(qts, "max", "kvm-steal-time");
465 
466     if (g_str_equal(qtest_get_arch(), "aarch64")) {
467         assert_has_feature_enabled(qts, "max", "aarch64");
468         assert_has_feature_enabled(qts, "max", "sve");
469         assert_has_feature_enabled(qts, "max", "sve128");
470         assert_has_feature_enabled(qts, "cortex-a57", "pmu");
471         assert_has_feature_enabled(qts, "cortex-a57", "aarch64");
472 
473         assert_has_feature_enabled(qts, "a64fx", "pmu");
474         assert_has_feature_enabled(qts, "a64fx", "aarch64");
475         /*
476          * A64FX does not support any other vector lengths besides those
477          * that are enabled by default(128bit, 256bits, 512bit).
478          */
479         assert_has_feature_enabled(qts, "a64fx", "sve");
480         assert_sve_vls(qts, "a64fx", 0xb, NULL);
481         assert_error(qts, "a64fx", "cannot enable sve384",
482                      "{ 'sve384': true }");
483         assert_error(qts, "a64fx", "cannot enable sve640",
484                      "{ 'sve640': true }");
485 
486         sve_tests_default(qts, "max");
487         pauth_tests_default(qts, "max");
488 
489         /* Test that features that depend on KVM generate errors without. */
490         assert_error(qts, "max",
491                      "'aarch64' feature cannot be disabled "
492                      "unless KVM is enabled and 32-bit EL1 "
493                      "is supported",
494                      "{ 'aarch64': false }");
495     }
496 
497     qtest_quit(qts);
498 }
499 
test_query_cpu_model_expansion_kvm(const void * data)500 static void test_query_cpu_model_expansion_kvm(const void *data)
501 {
502     QTestState *qts;
503 
504     qts = qtest_init(MACHINE_KVM "-cpu max");
505 
506     /* Enabling and disabling kvm-no-adjvtime should always work. */
507     assert_has_feature_disabled(qts, "host", "kvm-no-adjvtime");
508     assert_set_feature(qts, "host", "kvm-no-adjvtime", true);
509     assert_set_feature(qts, "host", "kvm-no-adjvtime", false);
510 
511     if (g_str_equal(qtest_get_arch(), "aarch64")) {
512         bool kvm_supports_pmu;
513         bool kvm_supports_steal_time;
514         bool kvm_supports_sve;
515         char max_name[8], name[8];
516         uint32_t max_vq, vq;
517         uint64_t vls;
518         QDict *resp;
519         char *error;
520 
521         /*
522          * When using KVM, only the 'host' and 'max' CPU models are
523          * supported. Test that we're emitting a suitable error for
524          * unsupported CPU models.
525          */
526         if (qtest_has_accel("tcg")) {
527             assert_error(qts, "cortex-a7",
528                          "We cannot guarantee the CPU type 'cortex-a7' works "
529                          "with KVM on this host", NULL);
530         } else {
531             /*
532              * With a KVM-only build the 32-bit CPUs are not present.
533              */
534             assert_error(qts, "cortex-a7",
535                          "The CPU type 'cortex-a7' is not a "
536                          "recognized ARM CPU type", NULL);
537         }
538 
539         assert_has_feature_enabled(qts, "host", "aarch64");
540 
541         /*
542          * Some features would be enabled by default, but they're disabled
543          * because this instance of KVM doesn't support them. Test that the
544          * features are present, and, when enabled, issue further tests.
545          */
546         assert_has_feature(qts, "host", "kvm-steal-time");
547         assert_has_feature(qts, "host", "sve");
548 
549         resp = do_query_no_props(qts, "host");
550         kvm_supports_pmu = resp_get_feature(resp, "pmu");
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);
554         qobject_unref(resp);
555 
556         if (kvm_supports_pmu) {
557             /* If we have pmu then we should be able to toggle it. */
558             assert_set_feature(qts, "host", "pmu", false);
559             assert_set_feature(qts, "host", "pmu", true);
560         }
561 
562         if (kvm_supports_steal_time) {
563             /* If we have steal-time then we should be able to toggle it. */
564             assert_set_feature(qts, "host", "kvm-steal-time", false);
565             assert_set_feature(qts, "host", "kvm-steal-time", true);
566         }
567 
568         if (kvm_supports_sve) {
569             g_assert(vls != 0);
570             max_vq = 64 - __builtin_clzll(vls);
571             sprintf(max_name, "sve%u", max_vq * 128);
572 
573             /* Enabling a supported length is of course fine. */
574             assert_sve_vls(qts, "host", vls, "{ %s: true }", max_name);
575 
576             /* Get the next supported length smaller than max-vq. */
577             vq = 64 - __builtin_clzll(vls & ~BIT_ULL(max_vq - 1));
578             if (vq) {
579                 /*
580                  * We have at least one length smaller than max-vq,
581                  * so we can disable max-vq.
582                  */
583                 assert_sve_vls(qts, "host", (vls & ~BIT_ULL(max_vq - 1)),
584                                "{ %s: false }", max_name);
585 
586                 /*
587                  * Smaller, supported vector lengths cannot be disabled
588                  * unless all larger, supported vector lengths are also
589                  * disabled.
590                  */
591                 sprintf(name, "sve%u", vq * 128);
592                 error = g_strdup_printf("cannot disable %s", name);
593                 assert_error(qts, "host", error,
594                              "{ %s: true, %s: false }",
595                              max_name, name);
596                 g_free(error);
597             }
598 
599             /*
600              * The smallest, supported vector length is required, because
601              * we need at least one vector length enabled.
602              */
603             vq = __builtin_ffsll(vls);
604             sprintf(name, "sve%u", vq * 128);
605             error = g_strdup_printf("cannot disable %s", name);
606             assert_error(qts, "host", error, "{ %s: false }", name);
607             g_free(error);
608 
609             /* Get an unsupported length. */
610             for (vq = 1; vq <= max_vq; ++vq) {
611                 if (!(vls & BIT_ULL(vq - 1))) {
612                     break;
613                 }
614             }
615             if (vq <= SVE_MAX_VQ) {
616                 sprintf(name, "sve%u", vq * 128);
617                 error = g_strdup_printf("cannot enable %s", name);
618                 assert_error(qts, "host", error, "{ %s: true }", name);
619                 g_free(error);
620             }
621         } else {
622             g_assert(vls == 0);
623         }
624     } else {
625         assert_has_not_feature(qts, "host", "aarch64");
626         assert_has_not_feature(qts, "host", "pmu");
627         assert_has_not_feature(qts, "host", "sve");
628         assert_has_not_feature(qts, "host", "kvm-steal-time");
629     }
630 
631     qtest_quit(qts);
632 }
633 
main(int argc,char ** argv)634 int main(int argc, char **argv)
635 {
636     g_test_init(&argc, &argv, NULL);
637 
638     if (!qtest_has_machine("virt")) {
639         goto out;
640     }
641 
642     if (qtest_has_accel("tcg")) {
643         qtest_add_data_func("/arm/query-cpu-model-expansion",
644                             NULL, test_query_cpu_model_expansion);
645     }
646 
647     if (!g_str_equal(qtest_get_arch(), "aarch64")) {
648         goto out;
649     }
650 
651     /*
652      * For now we only run KVM specific tests with AArch64 QEMU in
653      * order avoid attempting to run an AArch32 QEMU with KVM on
654      * AArch64 hosts. That won't work and isn't easy to detect.
655      */
656     if (qtest_has_accel("kvm")) {
657         /*
658          * This tests target the 'host' CPU type, so register it only if
659          * KVM is available.
660          */
661         qtest_add_data_func("/arm/kvm/query-cpu-model-expansion",
662                             NULL, test_query_cpu_model_expansion_kvm);
663 
664         qtest_add_data_func("/arm/kvm/query-cpu-model-expansion/sve-off",
665                             NULL, sve_tests_sve_off_kvm);
666     }
667 
668     if (qtest_has_accel("tcg")) {
669         qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-max-vq-8",
670                             NULL, sve_tests_sve_max_vq_8);
671         qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-off",
672                             NULL, sve_tests_sve_off);
673     }
674 
675 out:
676     return g_test_run();
677 }
678