qemu/tests/qtest/arm-cpu-features.c
<<
>>
Prefs
   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 -accel tcg "
  25#define QUERY_HEAD  "{ 'execute': 'query-cpu-model-expansion', " \
  26                    "  'arguments': { 'type': 'full', "
  27#define QUERY_TAIL  "}}"
  28
  29static bool kvm_enabled(QTestState *qts)
  30{
  31    QDict *resp, *qdict;
  32    bool enabled;
  33
  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");
  39    qobject_unref(resp);
  40
  41    return enabled;
  42}
  43
  44static QDict *do_query_no_props(QTestState *qts, const char *cpu_type)
  45{
  46    return qtest_qmp(qts, QUERY_HEAD "'model': { 'name': %s }"
  47                          QUERY_TAIL, cpu_type);
  48}
  49
  50static QDict *do_query(QTestState *qts, const char *cpu_type,
  51                       const char *fmt, ...)
  52{
  53    QDict *resp;
  54
  55    if (fmt) {
  56        QDict *args;
  57        va_list ap;
  58
  59        va_start(ap, fmt);
  60        args = qdict_from_vjsonf_nofail(fmt, ap);
  61        va_end(ap);
  62
  63        resp = qtest_qmp(qts, QUERY_HEAD "'model': { 'name': %s, "
  64                                                    "'props': %p }"
  65                              QUERY_TAIL, cpu_type, args);
  66    } else {
  67        resp = do_query_no_props(qts, cpu_type);
  68    }
  69
  70    return resp;
  71}
  72
  73static const char *resp_get_error(QDict *resp)
  74{
  75    QDict *qdict;
  76
  77    g_assert(resp);
  78
  79    qdict = qdict_get_qdict(resp, "error");
  80    if (qdict) {
  81        return qdict_get_str(qdict, "desc");
  82    }
  83
  84    return NULL;
  85}
  86
  87#define assert_error(qts, cpu_type, expected_error, fmt, ...)          \
  88({                                                                     \
  89    QDict *_resp;                                                      \
  90    const char *_error;                                                \
  91                                                                       \
  92    _resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__);               \
  93    g_assert(_resp);                                                   \
  94    _error = resp_get_error(_resp);                                    \
  95    g_assert(_error);                                                  \
  96    g_assert(g_str_equal(_error, expected_error));                     \
  97    qobject_unref(_resp);                                              \
  98})
  99
 100static bool resp_has_props(QDict *resp)
 101{
 102    QDict *qdict;
 103
 104    g_assert(resp);
 105
 106    if (!qdict_haskey(resp, "return")) {
 107        return false;
 108    }
 109    qdict = qdict_get_qdict(resp, "return");
 110
 111    if (!qdict_haskey(qdict, "model")) {
 112        return false;
 113    }
 114    qdict = qdict_get_qdict(qdict, "model");
 115
 116    return qdict_haskey(qdict, "props");
 117}
 118
 119static QDict *resp_get_props(QDict *resp)
 120{
 121    QDict *qdict;
 122
 123    g_assert(resp);
 124    g_assert(resp_has_props(resp));
 125
 126    qdict = qdict_get_qdict(resp, "return");
 127    qdict = qdict_get_qdict(qdict, "model");
 128    qdict = qdict_get_qdict(qdict, "props");
 129
 130    return qdict;
 131}
 132
 133static bool resp_get_feature(QDict *resp, const char *feature)
 134{
 135    QDict *props;
 136
 137    g_assert(resp);
 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);
 142}
 143
 144#define assert_has_feature(qts, cpu_type, feature)                     \
 145({                                                                     \
 146    QDict *_resp = do_query_no_props(qts, cpu_type);                   \
 147    g_assert(_resp);                                                   \
 148    g_assert(resp_has_props(_resp));                                   \
 149    g_assert(qdict_get(resp_get_props(_resp), feature));               \
 150    qobject_unref(_resp);                                              \
 151})
 152
 153#define assert_has_not_feature(qts, cpu_type, feature)                 \
 154({                                                                     \
 155    QDict *_resp = do_query_no_props(qts, cpu_type);                   \
 156    g_assert(_resp);                                                   \
 157    g_assert(!resp_has_props(_resp) ||                                 \
 158             !qdict_get(resp_get_props(_resp), feature));              \
 159    qobject_unref(_resp);                                              \
 160})
 161
 162#define resp_assert_feature(resp, feature, expected_value)             \
 163({                                                                     \
 164    QDict *_props;                                                     \
 165                                                                       \
 166    g_assert(_resp);                                                   \
 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));     \
 171})
 172
 173#define assert_feature(qts, cpu_type, feature, expected_value)         \
 174({                                                                     \
 175    QDict *_resp;                                                      \
 176                                                                       \
 177    _resp = do_query_no_props(qts, cpu_type);                          \
 178    g_assert(_resp);                                                   \
 179    resp_assert_feature(_resp, feature, expected_value);               \
 180    qobject_unref(_resp);                                              \
 181})
 182
 183#define assert_set_feature(qts, cpu_type, feature, value)              \
 184({                                                                     \
 185    const char *_fmt = (value) ? "{ %s: true }" : "{ %s: false }";     \
 186    QDict *_resp;                                                      \
 187                                                                       \
 188    _resp = do_query(qts, cpu_type, _fmt, feature);                    \
 189    g_assert(_resp);                                                   \
 190    resp_assert_feature(_resp, feature, value);                        \
 191    qobject_unref(_resp);                                              \
 192})
 193
 194#define assert_has_feature_enabled(qts, cpu_type, feature)             \
 195    assert_feature(qts, cpu_type, feature, true)
 196
 197#define assert_has_feature_disabled(qts, cpu_type, feature)            \
 198    assert_feature(qts, cpu_type, feature, false)
 199
 200static void assert_type_full(QTestState *qts)
 201{
 202    const char *error;
 203    QDict *resp;
 204
 205    resp = qtest_qmp(qts, "{ 'execute': 'query-cpu-model-expansion', "
 206                            "'arguments': { 'type': 'static', "
 207                                           "'model': { 'name': 'foo' }}}");
 208    g_assert(resp);
 209    error = resp_get_error(resp);
 210    g_assert(error);
 211    g_assert(g_str_equal(error,
 212                         "The requested expansion type is not supported"));
 213    qobject_unref(resp);
 214}
 215
 216static void assert_bad_props(QTestState *qts, const char *cpu_type)
 217{
 218    const char *error;
 219    QDict *resp;
 220
 221    resp = qtest_qmp(qts, "{ 'execute': 'query-cpu-model-expansion', "
 222                            "'arguments': { 'type': 'full', "
 223                                           "'model': { 'name': %s, "
 224                                                      "'props': false }}}",
 225                     cpu_type);
 226    g_assert(resp);
 227    error = resp_get_error(resp);
 228    g_assert(error);
 229    g_assert(g_str_equal(error,
 230                         "Invalid parameter type for 'props', expected: dict"));
 231    qobject_unref(resp);
 232}
 233
 234static uint64_t resp_get_sve_vls(QDict *resp)
 235{
 236    QDict *props;
 237    const QDictEntry *e;
 238    uint64_t vls = 0;
 239    int n = 0;
 240
 241    g_assert(resp);
 242    g_assert(resp_has_props(resp));
 243
 244    props = resp_get_props(resp);
 245
 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])) {
 249            char *endptr;
 250            int bits;
 251
 252            bits = g_ascii_strtoll(&e->key[3], &endptr, 10);
 253            if (!bits || *endptr != '\0') {
 254                continue;
 255            }
 256
 257            if (qdict_get_bool(props, e->key)) {
 258                vls |= BIT_ULL((bits / 128) - 1);
 259            }
 260            ++n;
 261        }
 262    }
 263
 264    g_assert(n == SVE_MAX_VQ);
 265
 266    return vls;
 267}
 268
 269#define assert_sve_vls(qts, cpu_type, expected_vls, fmt, ...)          \
 270({                                                                     \
 271    QDict *_resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__);        \
 272    g_assert(_resp);                                                   \
 273    g_assert(resp_has_props(_resp));                                   \
 274    g_assert(resp_get_sve_vls(_resp) == expected_vls);                 \
 275    qobject_unref(_resp);                                              \
 276})
 277
 278static void sve_tests_default(QTestState *qts, const char *cpu_type)
 279{
 280    /*
 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.
 284     */
 285    assert_sve_vls(qts, cpu_type, BIT_ULL(SVE_MAX_VQ) - 1, NULL);
 286
 287    /* With SVE off, all vector lengths should also be off. */
 288    assert_sve_vls(qts, cpu_type, 0, "{ 'sve': false }");
 289
 290    /* With SVE on, we must have at least one vector length enabled. */
 291    assert_error(qts, cpu_type, "cannot disable sve128", "{ 'sve128': false }");
 292
 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 }");
 297
 298    /*
 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     * ---------------------------------------------------------------------
 311     *
 312     * [*] "MUST" means this requirement must already be satisfied,
 313     *     otherwise 'max_vq' couldn't itself be enabled.
 314     *
 315     * [**] Not testable with the QMP interface, only with the command line.
 316     */
 317
 318    /* max_vq := 8 */
 319    assert_sve_vls(qts, cpu_type, 0x8b, "{ 'sve1024': true }");
 320
 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 }");
 326
 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 }");
 332
 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 }");
 336
 337    /*
 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.
 341     */
 342    assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve512': false }");
 343
 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 }");
 349}
 350
 351static void sve_tests_sve_max_vq_8(const void *data)
 352{
 353    QTestState *qts;
 354
 355    qts = qtest_init(MACHINE "-cpu max,sve-max-vq=8");
 356
 357    assert_sve_vls(qts, "max", BIT_ULL(8) - 1, NULL);
 358
 359    /*
 360     * Disabling the max-vq set by sve-max-vq is not allowed, but
 361     * of course enabling it is OK.
 362     */
 363    assert_error(qts, "max", "cannot disable sve1024", "{ 'sve1024': false }");
 364    assert_sve_vls(qts, "max", 0xff, "{ 'sve1024': true }");
 365
 366    /*
 367     * Enabling anything larger than max-vq set by sve-max-vq is not
 368     * allowed, but of course disabling everything larger is OK.
 369     */
 370    assert_error(qts, "max", "cannot enable sve1152", "{ 'sve1152': true }");
 371    assert_sve_vls(qts, "max", 0xff, "{ 'sve1152': false }");
 372
 373    /*
 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.
 377     */
 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 }");
 382
 383    qtest_quit(qts);
 384}
 385
 386static void sve_tests_sve_off(const void *data)
 387{
 388    QTestState *qts;
 389
 390    qts = qtest_init(MACHINE "-cpu max,sve=off");
 391
 392    /* SVE is off, so the map should be empty. */
 393    assert_sve_vls(qts, "max", 0, NULL);
 394
 395    /* The map stays empty even if we turn lengths off. */
 396    assert_sve_vls(qts, "max", 0, "{ 'sve128': false }");
 397
 398    /* It's an error to enable lengths when SVE is off. */
 399    assert_error(qts, "max", "cannot enable sve128", "{ 'sve128': true }");
 400
 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 }");
 403
 404    /* Or enable SVE with just specific vector lengths. */
 405    assert_sve_vls(qts, "max", 0x3,
 406                   "{ 'sve': true, 'sve128': true, 'sve256': true }");
 407
 408    qtest_quit(qts);
 409}
 410
 411static void sve_tests_sve_off_kvm(const void *data)
 412{
 413    QTestState *qts;
 414
 415    qts = qtest_init(MACHINE_KVM "-cpu max,sve=off");
 416
 417    /*
 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
 422     * lengths is OK too.
 423     */
 424    assert_sve_vls(qts, "max", 0, NULL);
 425    assert_sve_vls(qts, "max", 0, "{ 'sve128': false }");
 426
 427    qtest_quit(qts);
 428}
 429
 430static void test_query_cpu_model_expansion(const void *data)
 431{
 432    QTestState *qts;
 433
 434    qts = qtest_init(MACHINE "-cpu max");
 435
 436    /* Test common query-cpu-model-expansion input validation */
 437    assert_type_full(qts);
 438    assert_bad_props(qts, "max");
 439    assert_error(qts, "foo", "The CPU type 'foo' is not a recognized "
 440                 "ARM CPU type", NULL);
 441    assert_error(qts, "max", "Parameter 'not-a-prop' is unexpected",
 442                 "{ 'not-a-prop': false }");
 443    assert_error(qts, "host", "The CPU type 'host' requires KVM", NULL);
 444
 445    /* Test expected feature presence/absence for some cpu types */
 446    assert_has_feature_enabled(qts, "cortex-a15", "pmu");
 447    assert_has_not_feature(qts, "cortex-a15", "aarch64");
 448
 449    /* Enabling and disabling pmu should always work. */
 450    assert_has_feature_enabled(qts, "max", "pmu");
 451    assert_set_feature(qts, "max", "pmu", false);
 452    assert_set_feature(qts, "max", "pmu", true);
 453
 454    assert_has_not_feature(qts, "max", "kvm-no-adjvtime");
 455
 456    if (g_str_equal(qtest_get_arch(), "aarch64")) {
 457        assert_has_feature_enabled(qts, "max", "aarch64");
 458        assert_has_feature_enabled(qts, "max", "sve");
 459        assert_has_feature_enabled(qts, "max", "sve128");
 460        assert_has_feature_enabled(qts, "cortex-a57", "pmu");
 461        assert_has_feature_enabled(qts, "cortex-a57", "aarch64");
 462
 463        sve_tests_default(qts, "max");
 464
 465        /* Test that features that depend on KVM generate errors without. */
 466        assert_error(qts, "max",
 467                     "'aarch64' feature cannot be disabled "
 468                     "unless KVM is enabled and 32-bit EL1 "
 469                     "is supported",
 470                     "{ 'aarch64': false }");
 471    }
 472
 473    qtest_quit(qts);
 474}
 475
 476static void test_query_cpu_model_expansion_kvm(const void *data)
 477{
 478    QTestState *qts;
 479
 480    qts = qtest_init(MACHINE_KVM "-cpu max");
 481
 482    /*
 483     * These tests target the 'host' CPU type, so KVM must be enabled.
 484     */
 485    if (!kvm_enabled(qts)) {
 486        qtest_quit(qts);
 487        return;
 488    }
 489
 490    /* Enabling and disabling kvm-no-adjvtime should always work. */
 491    assert_has_feature_disabled(qts, "host", "kvm-no-adjvtime");
 492    assert_set_feature(qts, "host", "kvm-no-adjvtime", true);
 493    assert_set_feature(qts, "host", "kvm-no-adjvtime", false);
 494
 495    if (g_str_equal(qtest_get_arch(), "aarch64")) {
 496        bool kvm_supports_sve;
 497        char max_name[8], name[8];
 498        uint32_t max_vq, vq;
 499        uint64_t vls;
 500        QDict *resp;
 501        char *error;
 502
 503        assert_has_feature_enabled(qts, "host", "aarch64");
 504
 505        /* Enabling and disabling pmu should always work. */
 506        assert_has_feature_enabled(qts, "host", "pmu");
 507        assert_set_feature(qts, "host", "pmu", false);
 508        assert_set_feature(qts, "host", "pmu", true);
 509
 510        assert_error(qts, "cortex-a15",
 511            "We cannot guarantee the CPU type 'cortex-a15' works "
 512            "with KVM on this host", NULL);
 513
 514        assert_has_feature(qts, "host", "sve");
 515        resp = do_query_no_props(qts, "host");
 516        kvm_supports_sve = resp_get_feature(resp, "sve");
 517        vls = resp_get_sve_vls(resp);
 518        qobject_unref(resp);
 519
 520        if (kvm_supports_sve) {
 521            g_assert(vls != 0);
 522            max_vq = 64 - __builtin_clzll(vls);
 523            sprintf(max_name, "sve%d", max_vq * 128);
 524
 525            /* Enabling a supported length is of course fine. */
 526            assert_sve_vls(qts, "host", vls, "{ %s: true }", max_name);
 527
 528            /* Get the next supported length smaller than max-vq. */
 529            vq = 64 - __builtin_clzll(vls & ~BIT_ULL(max_vq - 1));
 530            if (vq) {
 531                /*
 532                 * We have at least one length smaller than max-vq,
 533                 * so we can disable max-vq.
 534                 */
 535                assert_sve_vls(qts, "host", (vls & ~BIT_ULL(max_vq - 1)),
 536                               "{ %s: false }", max_name);
 537
 538                /*
 539                 * Smaller, supported vector lengths cannot be disabled
 540                 * unless all larger, supported vector lengths are also
 541                 * disabled.
 542                 */
 543                sprintf(name, "sve%d", vq * 128);
 544                error = g_strdup_printf("cannot disable %s", name);
 545                assert_error(qts, "host", error,
 546                             "{ %s: true, %s: false }",
 547                             max_name, name);
 548                g_free(error);
 549            }
 550
 551            /*
 552             * The smallest, supported vector length is required, because
 553             * we need at least one vector length enabled.
 554             */
 555            vq = __builtin_ffsll(vls);
 556            sprintf(name, "sve%d", vq * 128);
 557            error = g_strdup_printf("cannot disable %s", name);
 558            assert_error(qts, "host", error, "{ %s: false }", name);
 559            g_free(error);
 560
 561            /* Get an unsupported length. */
 562            for (vq = 1; vq <= max_vq; ++vq) {
 563                if (!(vls & BIT_ULL(vq - 1))) {
 564                    break;
 565                }
 566            }
 567            if (vq <= SVE_MAX_VQ) {
 568                sprintf(name, "sve%d", vq * 128);
 569                error = g_strdup_printf("cannot enable %s", name);
 570                assert_error(qts, "host", error, "{ %s: true }", name);
 571                g_free(error);
 572            }
 573        } else {
 574            g_assert(vls == 0);
 575        }
 576    } else {
 577        assert_has_not_feature(qts, "host", "aarch64");
 578        assert_has_not_feature(qts, "host", "pmu");
 579        assert_has_not_feature(qts, "host", "sve");
 580    }
 581
 582    qtest_quit(qts);
 583}
 584
 585int main(int argc, char **argv)
 586{
 587    g_test_init(&argc, &argv, NULL);
 588
 589    qtest_add_data_func("/arm/query-cpu-model-expansion",
 590                        NULL, test_query_cpu_model_expansion);
 591
 592    /*
 593     * For now we only run KVM specific tests with AArch64 QEMU in
 594     * order avoid attempting to run an AArch32 QEMU with KVM on
 595     * AArch64 hosts. That won't work and isn't easy to detect.
 596     */
 597    if (g_str_equal(qtest_get_arch(), "aarch64")) {
 598        qtest_add_data_func("/arm/kvm/query-cpu-model-expansion",
 599                            NULL, test_query_cpu_model_expansion_kvm);
 600    }
 601
 602    if (g_str_equal(qtest_get_arch(), "aarch64")) {
 603        qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-max-vq-8",
 604                            NULL, sve_tests_sve_max_vq_8);
 605        qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-off",
 606                            NULL, sve_tests_sve_off);
 607        qtest_add_data_func("/arm/kvm/query-cpu-model-expansion/sve-off",
 608                            NULL, sve_tests_sve_off_kvm);
 609    }
 610
 611    return g_test_run();
 612}
 613