[mirror_qemu.git] / tests / arm-cpu-features.c

/*
 * Arm CPU feature test cases
 *
 * Copyright (c) 2019 Red Hat Inc.
 * Authors:
 *  Andrew Jones <drjones@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */
#include "qemu/osdep.h"
#include "qemu/bitops.h"
#include "libqtest.h"
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qjson.h"

/*
 * We expect the SVE max-vq to be 16. Also it must be <= 64
 * for our test code, otherwise 'vls' can't just be a uint64_t.
 */
#define SVE_MAX_VQ 16

#define MACHINE     "-machine virt,gic-version=max -accel tcg "
#define MACHINE_KVM "-machine virt,gic-version=max -accel kvm -accel tcg "
#define QUERY_HEAD  "{ 'execute': 'query-cpu-model-expansion', " \
                    "  'arguments': { 'type': 'full', "
#define QUERY_TAIL  "}}"

static bool kvm_enabled(QTestState *qts)
{
    QDict *resp, *qdict;
    bool enabled;

    resp = qtest_qmp(qts, "{ 'execute': 'query-kvm' }");
    g_assert(qdict_haskey(resp, "return"));
    qdict = qdict_get_qdict(resp, "return");
    g_assert(qdict_haskey(qdict, "enabled"));
    enabled = qdict_get_bool(qdict, "enabled");
    qobject_unref(resp);

    return enabled;
}

static QDict *do_query_no_props(QTestState *qts, const char *cpu_type)
{
    return qtest_qmp(qts, QUERY_HEAD "'model': { 'name': %s }"
                          QUERY_TAIL, cpu_type);
}

static QDict *do_query(QTestState *qts, const char *cpu_type,
                       const char *fmt, ...)
{
    QDict *resp;

    if (fmt) {
        QDict *args;
        va_list ap;

        va_start(ap, fmt);
        args = qdict_from_vjsonf_nofail(fmt, ap);
        va_end(ap);

        resp = qtest_qmp(qts, QUERY_HEAD "'model': { 'name': %s, "
                                                    "'props': %p }"
                              QUERY_TAIL, cpu_type, args);
    } else {
        resp = do_query_no_props(qts, cpu_type);
    }

    return resp;
}

static const char *resp_get_error(QDict *resp)
{
    QDict *qdict;

    g_assert(resp);

    qdict = qdict_get_qdict(resp, "error");
    if (qdict) {
        return qdict_get_str(qdict, "desc");
    }

    return NULL;
}

#define assert_error(qts, cpu_type, expected_error, fmt, ...)          \
({                                                                     \
    QDict *_resp;                                                      \
    const char *_error;                                                \
                                                                       \
    _resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__);               \
    g_assert(_resp);                                                   \
    _error = resp_get_error(_resp);                                    \
    g_assert(_error);                                                  \
    g_assert(g_str_equal(_error, expected_error));                     \
    qobject_unref(_resp);                                              \
})

static bool resp_has_props(QDict *resp)
{
    QDict *qdict;

    g_assert(resp);

    if (!qdict_haskey(resp, "return")) {
        return false;
    }
    qdict = qdict_get_qdict(resp, "return");

    if (!qdict_haskey(qdict, "model")) {
        return false;
    }
    qdict = qdict_get_qdict(qdict, "model");

    return qdict_haskey(qdict, "props");
}

static QDict *resp_get_props(QDict *resp)
{
    QDict *qdict;

    g_assert(resp);
    g_assert(resp_has_props(resp));

    qdict = qdict_get_qdict(resp, "return");
    qdict = qdict_get_qdict(qdict, "model");
    qdict = qdict_get_qdict(qdict, "props");

    return qdict;
}

static bool resp_get_feature(QDict *resp, const char *feature)
{
    QDict *props;

    g_assert(resp);
    g_assert(resp_has_props(resp));
    props = resp_get_props(resp);
    g_assert(qdict_get(props, feature));
    return qdict_get_bool(props, feature);
}

#define assert_has_feature(qts, cpu_type, feature)                     \
({                                                                     \
    QDict *_resp = do_query_no_props(qts, cpu_type);                   \
    g_assert(_resp);                                                   \
    g_assert(resp_has_props(_resp));                                   \
    g_assert(qdict_get(resp_get_props(_resp), feature));               \
    qobject_unref(_resp);                                              \
})

#define assert_has_not_feature(qts, cpu_type, feature)                 \
({                                                                     \
    QDict *_resp = do_query_no_props(qts, cpu_type);                   \
    g_assert(_resp);                                                   \
    g_assert(!resp_has_props(_resp) ||                                 \
             !qdict_get(resp_get_props(_resp), feature));              \
    qobject_unref(_resp);                                              \
})

static void assert_type_full(QTestState *qts)
{
    const char *error;
    QDict *resp;

    resp = qtest_qmp(qts, "{ 'execute': 'query-cpu-model-expansion', "
                            "'arguments': { 'type': 'static', "
                                           "'model': { 'name': 'foo' }}}");
    g_assert(resp);
    error = resp_get_error(resp);
    g_assert(error);
    g_assert(g_str_equal(error,
                         "The requested expansion type is not supported"));
    qobject_unref(resp);
}

static void assert_bad_props(QTestState *qts, const char *cpu_type)
{
    const char *error;
    QDict *resp;

    resp = qtest_qmp(qts, "{ 'execute': 'query-cpu-model-expansion', "
                            "'arguments': { 'type': 'full', "
                                           "'model': { 'name': %s, "
                                                      "'props': false }}}",
                     cpu_type);
    g_assert(resp);
    error = resp_get_error(resp);
    g_assert(error);
    g_assert(g_str_equal(error,
                         "Invalid parameter type for 'props', expected: dict"));
    qobject_unref(resp);
}

static uint64_t resp_get_sve_vls(QDict *resp)
{
    QDict *props;
    const QDictEntry *e;
    uint64_t vls = 0;
    int n = 0;

    g_assert(resp);
    g_assert(resp_has_props(resp));

    props = resp_get_props(resp);

    for (e = qdict_first(props); e; e = qdict_next(props, e)) {
        if (strlen(e->key) > 3 && !strncmp(e->key, "sve", 3) &&
            g_ascii_isdigit(e->key[3])) {
            char *endptr;
            int bits;

            bits = g_ascii_strtoll(&e->key[3], &endptr, 10);
            if (!bits || *endptr != '\0') {
                continue;
            }

            if (qdict_get_bool(props, e->key)) {
                vls |= BIT_ULL((bits / 128) - 1);
            }
            ++n;
        }
    }

    g_assert(n == SVE_MAX_VQ);

    return vls;
}

#define assert_sve_vls(qts, cpu_type, expected_vls, fmt, ...)          \
({                                                                     \
    QDict *_resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__);        \
    g_assert(_resp);                                                   \
    g_assert(resp_has_props(_resp));                                   \
    g_assert(resp_get_sve_vls(_resp) == expected_vls);                 \
    qobject_unref(_resp);                                              \
})

static void sve_tests_default(QTestState *qts, const char *cpu_type)
{
    /*
     * With no sve-max-vq or sve<N> properties on the command line
     * the default is to have all vector lengths enabled. This also
     * tests that 'sve' is 'on' by default.
     */
    assert_sve_vls(qts, cpu_type, BIT_ULL(SVE_MAX_VQ) - 1, NULL);

    /* With SVE off, all vector lengths should also be off. */
    assert_sve_vls(qts, cpu_type, 0, "{ 'sve': false }");

    /* With SVE on, we must have at least one vector length enabled. */
    assert_error(qts, cpu_type, "cannot disable sve128", "{ 'sve128': false }");

    /* Basic enable/disable tests. */
    assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve384': true }");
    assert_sve_vls(qts, cpu_type, ((BIT_ULL(SVE_MAX_VQ) - 1) & ~BIT_ULL(2)),
                   "{ 'sve384': false }");

    /*
     * ---------------------------------------------------------------------
     *               power-of-two(vq)   all-power-            can      can
     *                                  of-two(< vq)        enable   disable
     * ---------------------------------------------------------------------
     * vq < max_vq      no                MUST*              yes      yes
     * vq < max_vq      yes               MUST*              yes      no
     * ---------------------------------------------------------------------
     * vq == max_vq     n/a               MUST*              yes**    yes**
     * ---------------------------------------------------------------------
     * vq > max_vq      n/a               no                 no       yes
     * vq > max_vq      n/a               yes                yes      yes
     * ---------------------------------------------------------------------
     *
     * [*] "MUST" means this requirement must already be satisfied,
     *     otherwise 'max_vq' couldn't itself be enabled.
     *
     * [**] Not testable with the QMP interface, only with the command line.
     */

    /* max_vq := 8 */
    assert_sve_vls(qts, cpu_type, 0x8b, "{ 'sve1024': true }");

    /* max_vq := 8, vq < max_vq, !power-of-two(vq) */
    assert_sve_vls(qts, cpu_type, 0x8f,
                   "{ 'sve1024': true, 'sve384': true }");
    assert_sve_vls(qts, cpu_type, 0x8b,
                   "{ 'sve1024': true, 'sve384': false }");

    /* max_vq := 8, vq < max_vq, power-of-two(vq) */
    assert_sve_vls(qts, cpu_type, 0x8b,
                   "{ 'sve1024': true, 'sve256': true }");
    assert_error(qts, cpu_type, "cannot disable sve256",
                 "{ 'sve1024': true, 'sve256': false }");

    /* max_vq := 3, vq > max_vq, !all-power-of-two(< vq) */
    assert_error(qts, cpu_type, "cannot disable sve512",
                 "{ 'sve384': true, 'sve512': false, 'sve640': true }");

    /*
     * We can disable power-of-two vector lengths when all larger lengths
     * are also disabled. We only need to disable the power-of-two length,
     * as all non-enabled larger lengths will then be auto-disabled.
     */
    assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve512': false }");

    /* max_vq := 3, vq > max_vq, all-power-of-two(< vq) */
    assert_sve_vls(qts, cpu_type, 0x1f,
                   "{ 'sve384': true, 'sve512': true, 'sve640': true }");
    assert_sve_vls(qts, cpu_type, 0xf,
                   "{ 'sve384': true, 'sve512': true, 'sve640': false }");
}

static void sve_tests_sve_max_vq_8(const void *data)
{
    QTestState *qts;

    qts = qtest_init(MACHINE "-cpu max,sve-max-vq=8");

    assert_sve_vls(qts, "max", BIT_ULL(8) - 1, NULL);

    /*
     * Disabling the max-vq set by sve-max-vq is not allowed, but
     * of course enabling it is OK.
     */
    assert_error(qts, "max", "cannot disable sve1024", "{ 'sve1024': false }");
    assert_sve_vls(qts, "max", 0xff, "{ 'sve1024': true }");

    /*
     * Enabling anything larger than max-vq set by sve-max-vq is not
     * allowed, but of course disabling everything larger is OK.
     */
    assert_error(qts, "max", "cannot enable sve1152", "{ 'sve1152': true }");
    assert_sve_vls(qts, "max", 0xff, "{ 'sve1152': false }");

    /*
     * We can enable/disable non power-of-two lengths smaller than the
     * max-vq set by sve-max-vq, but, while we can enable power-of-two
     * lengths, we can't disable them.
     */
    assert_sve_vls(qts, "max", 0xff, "{ 'sve384': true }");
    assert_sve_vls(qts, "max", 0xfb, "{ 'sve384': false }");
    assert_sve_vls(qts, "max", 0xff, "{ 'sve256': true }");
    assert_error(qts, "max", "cannot disable sve256", "{ 'sve256': false }");

    qtest_quit(qts);
}

static void sve_tests_sve_off(const void *data)
{
    QTestState *qts;

    qts = qtest_init(MACHINE "-cpu max,sve=off");

    /* SVE is off, so the map should be empty. */
    assert_sve_vls(qts, "max", 0, NULL);

    /* The map stays empty even if we turn lengths off. */
    assert_sve_vls(qts, "max", 0, "{ 'sve128': false }");

    /* It's an error to enable lengths when SVE is off. */
    assert_error(qts, "max", "cannot enable sve128", "{ 'sve128': true }");

    /* With SVE re-enabled we should get all vector lengths enabled. */
    assert_sve_vls(qts, "max", BIT_ULL(SVE_MAX_VQ) - 1, "{ 'sve': true }");

    /* Or enable SVE with just specific vector lengths. */
    assert_sve_vls(qts, "max", 0x3,
                   "{ 'sve': true, 'sve128': true, 'sve256': true }");

    qtest_quit(qts);
}

static void sve_tests_sve_off_kvm(const void *data)
{
    QTestState *qts;

    qts = qtest_init(MACHINE_KVM "-cpu max,sve=off");

    /*
     * We don't know if this host supports SVE so we don't
     * attempt to test enabling anything. We only test that
     * everything is disabled (as it should be with sve=off)
     * and that using sve<N>=off to explicitly disable vector
     * lengths is OK too.
     */
    assert_sve_vls(qts, "max", 0, NULL);
    assert_sve_vls(qts, "max", 0, "{ 'sve128': false }");

    qtest_quit(qts);
}

static void test_query_cpu_model_expansion(const void *data)
{
    QTestState *qts;

    qts = qtest_init(MACHINE "-cpu max");

    /* Test common query-cpu-model-expansion input validation */
    assert_type_full(qts);
    assert_bad_props(qts, "max");
    assert_error(qts, "foo", "The CPU type 'foo' is not a recognized "
                 "ARM CPU type", NULL);
    assert_error(qts, "max", "Parameter 'not-a-prop' is unexpected",
                 "{ 'not-a-prop': false }");
    assert_error(qts, "host", "The CPU type 'host' requires KVM", NULL);

    /* Test expected feature presence/absence for some cpu types */
    assert_has_feature(qts, "max", "pmu");
    assert_has_feature(qts, "cortex-a15", "pmu");
    assert_has_not_feature(qts, "cortex-a15", "aarch64");

    if (g_str_equal(qtest_get_arch(), "aarch64")) {
        assert_has_feature(qts, "max", "aarch64");
        assert_has_feature(qts, "max", "sve");
        assert_has_feature(qts, "max", "sve128");
        assert_has_feature(qts, "cortex-a57", "pmu");
        assert_has_feature(qts, "cortex-a57", "aarch64");

        sve_tests_default(qts, "max");

        /* Test that features that depend on KVM generate errors without. */
        assert_error(qts, "max",
                     "'aarch64' feature cannot be disabled "
                     "unless KVM is enabled and 32-bit EL1 "
                     "is supported",
                     "{ 'aarch64': false }");
    }

    qtest_quit(qts);
}

static void test_query_cpu_model_expansion_kvm(const void *data)
{
    QTestState *qts;

    qts = qtest_init(MACHINE_KVM "-cpu max");

    /*
     * These tests target the 'host' CPU type, so KVM must be enabled.
     */
    if (!kvm_enabled(qts)) {
        qtest_quit(qts);
        return;
    }

    if (g_str_equal(qtest_get_arch(), "aarch64")) {
        bool kvm_supports_sve;
        char max_name[8], name[8];
        uint32_t max_vq, vq;
        uint64_t vls;
        QDict *resp;
        char *error;

        assert_has_feature(qts, "host", "aarch64");
        assert_has_feature(qts, "host", "pmu");

        assert_error(qts, "cortex-a15",
            "We cannot guarantee the CPU type 'cortex-a15' works "
            "with KVM on this host", NULL);

        assert_has_feature(qts, "host", "sve");
        resp = do_query_no_props(qts, "host");
        kvm_supports_sve = resp_get_feature(resp, "sve");
        vls = resp_get_sve_vls(resp);
        qobject_unref(resp);

        if (kvm_supports_sve) {
            g_assert(vls != 0);
            max_vq = 64 - __builtin_clzll(vls);
            sprintf(max_name, "sve%d", max_vq * 128);

            /* Enabling a supported length is of course fine. */
            assert_sve_vls(qts, "host", vls, "{ %s: true }", max_name);

            /* Get the next supported length smaller than max-vq. */
            vq = 64 - __builtin_clzll(vls & ~BIT_ULL(max_vq - 1));
            if (vq) {
                /*
                 * We have at least one length smaller than max-vq,
                 * so we can disable max-vq.
                 */
                assert_sve_vls(qts, "host", (vls & ~BIT_ULL(max_vq - 1)),
                               "{ %s: false }", max_name);

                /*
                 * Smaller, supported vector lengths cannot be disabled
                 * unless all larger, supported vector lengths are also
                 * disabled.
                 */
                sprintf(name, "sve%d", vq * 128);
                error = g_strdup_printf("cannot disable %s", name);
                assert_error(qts, "host", error,
                             "{ %s: true, %s: false }",
                             max_name, name);
                g_free(error);
            }

            /*
             * The smallest, supported vector length is required, because
             * we need at least one vector length enabled.
             */
            vq = __builtin_ffsll(vls);
            sprintf(name, "sve%d", vq * 128);
            error = g_strdup_printf("cannot disable %s", name);
            assert_error(qts, "host", error, "{ %s: false }", name);
            g_free(error);

            /* Get an unsupported length. */
            for (vq = 1; vq <= max_vq; ++vq) {
                if (!(vls & BIT_ULL(vq - 1))) {
                    break;
                }
            }
            if (vq <= SVE_MAX_VQ) {
                sprintf(name, "sve%d", vq * 128);
                error = g_strdup_printf("cannot enable %s", name);
                assert_error(qts, "host", error, "{ %s: true }", name);
                g_free(error);
            }
        } else {
            g_assert(vls == 0);
        }
    } else {
        assert_has_not_feature(qts, "host", "aarch64");
        assert_has_not_feature(qts, "host", "pmu");
        assert_has_not_feature(qts, "host", "sve");
    }

    qtest_quit(qts);
}

int main(int argc, char **argv)
{
    g_test_init(&argc, &argv, NULL);

    qtest_add_data_func("/arm/query-cpu-model-expansion",
                        NULL, test_query_cpu_model_expansion);

    /*
     * For now we only run KVM specific tests with AArch64 QEMU in
     * order avoid attempting to run an AArch32 QEMU with KVM on
     * AArch64 hosts. That won't work and isn't easy to detect.
     */
    if (g_str_equal(qtest_get_arch(), "aarch64")) {
        qtest_add_data_func("/arm/kvm/query-cpu-model-expansion",
                            NULL, test_query_cpu_model_expansion_kvm);
    }

    if (g_str_equal(qtest_get_arch(), "aarch64")) {
        qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-max-vq-8",
                            NULL, sve_tests_sve_max_vq_8);
        qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-off",
                            NULL, sve_tests_sve_off);
        qtest_add_data_func("/arm/kvm/query-cpu-model-expansion/sve-off",
                            NULL, sve_tests_sve_off_kvm);
    }

    return g_test_run();
}
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"
bd31b751 AJ	13	#include "libqtest.h"
	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 "
6f6e1698 PB	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
	29	static 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
	44	static 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
	50	static 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
	73	static 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
100	static 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
119	static 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
6fa8a379 AJ	133	static 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
bd31b751 AJ	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	static void assert_type_full(QTestState *qts)
	163	{
	164	const char *error;
	165	QDict *resp;
	166
	167	resp = qtest_qmp(qts, "{ 'execute': 'query-cpu-model-expansion', "
	168	"'arguments': { 'type': 'static', "
	169	"'model': { 'name': 'foo' }}}");
	170	g_assert(resp);
	171	error = resp_get_error(resp);
	172	g_assert(error);
	173	g_assert(g_str_equal(error,
	174	"The requested expansion type is not supported"));
	175	qobject_unref(resp);
	176	}
	177
	178	static void assert_bad_props(QTestState qts, const char cpu_type)
	179	{
	180	const char *error;
	181	QDict *resp;
	182
	183	resp = qtest_qmp(qts, "{ 'execute': 'query-cpu-model-expansion', "
	184	"'arguments': { 'type': 'full', "
	185	"'model': { 'name': %s, "
	186	"'props': false }}}",
	187	cpu_type);
	188	g_assert(resp);
	189	error = resp_get_error(resp);
	190	g_assert(error);
	191	g_assert(g_str_equal(error,
	192	"Invalid parameter type for 'props', expected: dict"));
	193	qobject_unref(resp);
	194	}
	195
0df9142d AJ	196	static uint64_t resp_get_sve_vls(QDict *resp)
	197	{
	198	QDict *props;
	199	const QDictEntry *e;
	200	uint64_t vls = 0;
	201	int n = 0;
	202
	203	g_assert(resp);
	204	g_assert(resp_has_props(resp));
	205
	206	props = resp_get_props(resp);
	207
	208	for (e = qdict_first(props); e; e = qdict_next(props, e)) {
	209	if (strlen(e->key) > 3 && !strncmp(e->key, "sve", 3) &&
	210	g_ascii_isdigit(e->key[3])) {
	211	char *endptr;
	212	int bits;
	213
	214	bits = g_ascii_strtoll(&e->key[3], &endptr, 10);
	215	if (!bits \|\| *endptr != '\0') {
	216	continue;
	217	}
	218
	219	if (qdict_get_bool(props, e->key)) {
	220	vls \|= BIT_ULL((bits / 128) - 1);
	221	}
	222	++n;
	223	}
	224	}
	225
	226	g_assert(n == SVE_MAX_VQ);
	227
	228	return vls;
	229	}
	230
	231	#define assert_sve_vls(qts, cpu_type, expected_vls, fmt, ...) \
	232	({ \
	233	QDict *_resp = do_query(qts, cpu_type, fmt, ##__VA_ARGS__); \
	234	g_assert(_resp); \
	235	g_assert(resp_has_props(_resp)); \
	236	g_assert(resp_get_sve_vls(_resp) == expected_vls); \
	237	qobject_unref(_resp); \
	238	})
	239
	240	static void sve_tests_default(QTestState qts, const char cpu_type)
	241	{
	242	/*
	243	* With no sve-max-vq or sve<N> properties on the command line
	244	* the default is to have all vector lengths enabled. This also
	245	* tests that 'sve' is 'on' by default.
	246	*/
	247	assert_sve_vls(qts, cpu_type, BIT_ULL(SVE_MAX_VQ) - 1, NULL);
	248
	249	/* With SVE off, all vector lengths should also be off. */
	250	assert_sve_vls(qts, cpu_type, 0, "{ 'sve': false }");
	251
	252	/* With SVE on, we must have at least one vector length enabled. */
	253	assert_error(qts, cpu_type, "cannot disable sve128", "{ 'sve128': false }");
	254
	255	/* Basic enable/disable tests. */
	256	assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve384': true }");
	257	assert_sve_vls(qts, cpu_type, ((BIT_ULL(SVE_MAX_VQ) - 1) & ~BIT_ULL(2)),
	258	"{ 'sve384': false }");
	259
260	/*
261	* ---------------------------------------------------------------------
262	* power-of-two(vq) all-power- can can
263	* of-two(< vq) enable disable
264	* ---------------------------------------------------------------------
265	* vq < max_vq no MUST* yes yes
266	* vq < max_vq yes MUST* yes no
267	* ---------------------------------------------------------------------
268	* vq == max_vq n/a MUST* yes yes
269	* ---------------------------------------------------------------------
270	* vq > max_vq n/a no no yes
271	* vq > max_vq n/a yes yes yes
272	* ---------------------------------------------------------------------
273	*
274	* [*] "MUST" means this requirement must already be satisfied,
275	* otherwise 'max_vq' couldn't itself be enabled.
276	*
277	* [**] Not testable with the QMP interface, only with the command line.
278	*/
279
280	/* max_vq := 8 */
281	assert_sve_vls(qts, cpu_type, 0x8b, "{ 'sve1024': true }");
282
283	/* max_vq := 8, vq < max_vq, !power-of-two(vq) */
284	assert_sve_vls(qts, cpu_type, 0x8f,
285	"{ 'sve1024': true, 'sve384': true }");
286	assert_sve_vls(qts, cpu_type, 0x8b,
287	"{ 'sve1024': true, 'sve384': false }");
288
289	/* max_vq := 8, vq < max_vq, power-of-two(vq) */
290	assert_sve_vls(qts, cpu_type, 0x8b,
291	"{ 'sve1024': true, 'sve256': true }");
292	assert_error(qts, cpu_type, "cannot disable sve256",
293	"{ 'sve1024': true, 'sve256': false }");
294
295	/* max_vq := 3, vq > max_vq, !all-power-of-two(< vq) */
296	assert_error(qts, cpu_type, "cannot disable sve512",
297	"{ 'sve384': true, 'sve512': false, 'sve640': true }");
298
299	/*
300	* We can disable power-of-two vector lengths when all larger lengths
301	* are also disabled. We only need to disable the power-of-two length,
302	* as all non-enabled larger lengths will then be auto-disabled.
303	*/
304	assert_sve_vls(qts, cpu_type, 0x7, "{ 'sve512': false }");
305
306	/* max_vq := 3, vq > max_vq, all-power-of-two(< vq) */
307	assert_sve_vls(qts, cpu_type, 0x1f,
308	"{ 'sve384': true, 'sve512': true, 'sve640': true }");
309	assert_sve_vls(qts, cpu_type, 0xf,
310	"{ 'sve384': true, 'sve512': true, 'sve640': false }");
311	}
312
313	static void sve_tests_sve_max_vq_8(const void *data)
314	{
315	QTestState *qts;
316
317	qts = qtest_init(MACHINE "-cpu max,sve-max-vq=8");
318
319	assert_sve_vls(qts, "max", BIT_ULL(8) - 1, NULL);
320
321	/*
322	* Disabling the max-vq set by sve-max-vq is not allowed, but
323	* of course enabling it is OK.
324	*/
325	assert_error(qts, "max", "cannot disable sve1024", "{ 'sve1024': false }");
326	assert_sve_vls(qts, "max", 0xff, "{ 'sve1024': true }");
327
328	/*
329	* Enabling anything larger than max-vq set by sve-max-vq is not
330	* allowed, but of course disabling everything larger is OK.
331	*/
332	assert_error(qts, "max", "cannot enable sve1152", "{ 'sve1152': true }");
333	assert_sve_vls(qts, "max", 0xff, "{ 'sve1152': false }");
334
335	/*
336	* We can enable/disable non power-of-two lengths smaller than the
337	* max-vq set by sve-max-vq, but, while we can enable power-of-two
338	* lengths, we can't disable them.
339	*/
340	assert_sve_vls(qts, "max", 0xff, "{ 'sve384': true }");
341	assert_sve_vls(qts, "max", 0xfb, "{ 'sve384': false }");
342	assert_sve_vls(qts, "max", 0xff, "{ 'sve256': true }");
343	assert_error(qts, "max", "cannot disable sve256", "{ 'sve256': false }");
344
345	qtest_quit(qts);
346	}
347
348	static void sve_tests_sve_off(const void *data)
349	{
350	QTestState *qts;
351
352	qts = qtest_init(MACHINE "-cpu max,sve=off");
353
354	/* SVE is off, so the map should be empty. */
355	assert_sve_vls(qts, "max", 0, NULL);
356
357	/* The map stays empty even if we turn lengths off. */
358	assert_sve_vls(qts, "max", 0, "{ 'sve128': false }");
359
360	/* It's an error to enable lengths when SVE is off. */
361	assert_error(qts, "max", "cannot enable sve128", "{ 'sve128': true }");
362
363	/* With SVE re-enabled we should get all vector lengths enabled. */
364	assert_sve_vls(qts, "max", BIT_ULL(SVE_MAX_VQ) - 1, "{ 'sve': true }");
365
366	/* Or enable SVE with just specific vector lengths. */
367	assert_sve_vls(qts, "max", 0x3,
368	"{ 'sve': true, 'sve128': true, 'sve256': true }");
369
370	qtest_quit(qts);
371	}
372
6fa8a379 AJ	373	static void sve_tests_sve_off_kvm(const void *data)
	374	{
	375	QTestState *qts;
	376
	377	qts = qtest_init(MACHINE_KVM "-cpu max,sve=off");
	378
	379	/*
	380	* We don't know if this host supports SVE so we don't
	381	* attempt to test enabling anything. We only test that
	382	* everything is disabled (as it should be with sve=off)
	383	* and that using sve<N>=off to explicitly disable vector
	384	* lengths is OK too.
	385	*/
	386	assert_sve_vls(qts, "max", 0, NULL);
	387	assert_sve_vls(qts, "max", 0, "{ 'sve128': false }");
	388
	389	qtest_quit(qts);
	390	}
	391
bd31b751 AJ	392	static void test_query_cpu_model_expansion(const void *data)
	393	{
	394	QTestState *qts;
	395
	396	qts = qtest_init(MACHINE "-cpu max");
	397
	398	/* Test common query-cpu-model-expansion input validation */
	399	assert_type_full(qts);
	400	assert_bad_props(qts, "max");
	401	assert_error(qts, "foo", "The CPU type 'foo' is not a recognized "
	402	"ARM CPU type", NULL);
	403	assert_error(qts, "max", "Parameter 'not-a-prop' is unexpected",
	404	"{ 'not-a-prop': false }");
	405	assert_error(qts, "host", "The CPU type 'host' requires KVM", NULL);
	406
	407	/* Test expected feature presence/absence for some cpu types */
	408	assert_has_feature(qts, "max", "pmu");
	409	assert_has_feature(qts, "cortex-a15", "pmu");
	410	assert_has_not_feature(qts, "cortex-a15", "aarch64");
	411
	412	if (g_str_equal(qtest_get_arch(), "aarch64")) {
	413	assert_has_feature(qts, "max", "aarch64");
73234775	414	assert_has_feature(qts, "max", "sve");
0df9142d	415	assert_has_feature(qts, "max", "sve128");
bd31b751 AJ	416	assert_has_feature(qts, "cortex-a57", "pmu");
	417	assert_has_feature(qts, "cortex-a57", "aarch64");
	418
0df9142d AJ	419	sve_tests_default(qts, "max");
0df9142d AJ	420
bd31b751 AJ	421	/* Test that features that depend on KVM generate errors without. */
	422	assert_error(qts, "max",
	423	"'aarch64' feature cannot be disabled "
	424	"unless KVM is enabled and 32-bit EL1 "
	425	"is supported",
	426	"{ 'aarch64': false }");
	427	}
	428
	429	qtest_quit(qts);
	430	}
	431
	432	static void test_query_cpu_model_expansion_kvm(const void *data)
	433	{
	434	QTestState *qts;
	435
	436	qts = qtest_init(MACHINE_KVM "-cpu max");
	437
	438	/*
	439	* These tests target the 'host' CPU type, so KVM must be enabled.
	440	*/
	441	if (!kvm_enabled(qts)) {
	442	qtest_quit(qts);
	443	return;
	444	}
	445
	446	if (g_str_equal(qtest_get_arch(), "aarch64")) {
6fa8a379 AJ	447	bool kvm_supports_sve;
	448	char max_name[8], name[8];
	449	uint32_t max_vq, vq;
	450	uint64_t vls;
	451	QDict *resp;
	452	char *error;
	453
bd31b751 AJ	454	assert_has_feature(qts, "host", "aarch64");
	455	assert_has_feature(qts, "host", "pmu");
	456
	457	assert_error(qts, "cortex-a15",
	458	"We cannot guarantee the CPU type 'cortex-a15' works "
	459	"with KVM on this host", NULL);
6fa8a379	460
87014c6b AJ	461	assert_has_feature(qts, "host", "sve");
87014c6b AJ	462	resp = do_query_no_props(qts, "host");
6fa8a379 AJ	463	kvm_supports_sve = resp_get_feature(resp, "sve");
	464	vls = resp_get_sve_vls(resp);
	465	qobject_unref(resp);
	466
	467	if (kvm_supports_sve) {
	468	g_assert(vls != 0);
	469	max_vq = 64 - __builtin_clzll(vls);
	470	sprintf(max_name, "sve%d", max_vq * 128);
	471
	472	/* Enabling a supported length is of course fine. */
87014c6b	473	assert_sve_vls(qts, "host", vls, "{ %s: true }", max_name);
6fa8a379 AJ	474
	475	/* Get the next supported length smaller than max-vq. */
	476	vq = 64 - __builtin_clzll(vls & ~BIT_ULL(max_vq - 1));
	477	if (vq) {
	478	/*
	479	* We have at least one length smaller than max-vq,
	480	* so we can disable max-vq.
	481	*/
87014c6b	482	assert_sve_vls(qts, "host", (vls & ~BIT_ULL(max_vq - 1)),
6fa8a379 AJ	483	"{ %s: false }", max_name);
	484
	485	/*
	486	* Smaller, supported vector lengths cannot be disabled
	487	* unless all larger, supported vector lengths are also
	488	* disabled.
	489	*/
	490	sprintf(name, "sve%d", vq * 128);
	491	error = g_strdup_printf("cannot disable %s", name);
87014c6b	492	assert_error(qts, "host", error,
6fa8a379 AJ	493	"{ %s: true, %s: false }",
	494	max_name, name);
	495	g_free(error);
	496	}
	497
	498	/*
	499	* The smallest, supported vector length is required, because
	500	* we need at least one vector length enabled.
	501	*/
	502	vq = __builtin_ffsll(vls);
	503	sprintf(name, "sve%d", vq * 128);
	504	error = g_strdup_printf("cannot disable %s", name);
87014c6b	505	assert_error(qts, "host", error, "{ %s: false }", name);
6fa8a379 AJ	506	g_free(error);
	507
	508	/* Get an unsupported length. */
	509	for (vq = 1; vq <= max_vq; ++vq) {
	510	if (!(vls & BIT_ULL(vq - 1))) {
	511	break;
	512	}
	513	}
	514	if (vq <= SVE_MAX_VQ) {
	515	sprintf(name, "sve%d", vq * 128);
	516	error = g_strdup_printf("cannot enable %s", name);
87014c6b	517	assert_error(qts, "host", error, "{ %s: true }", name);
6fa8a379 AJ	518	g_free(error);
	519	}
	520	} else {
	521	g_assert(vls == 0);
	522	}
bd31b751 AJ	523	} else {
	524	assert_has_not_feature(qts, "host", "aarch64");
	525	assert_has_not_feature(qts, "host", "pmu");
87014c6b	526	assert_has_not_feature(qts, "host", "sve");
bd31b751 AJ	527	}
	528
	529	qtest_quit(qts);
	530	}
	531
	532	int main(int argc, char **argv)
	533	{
	534	g_test_init(&argc, &argv, NULL);
	535
	536	qtest_add_data_func("/arm/query-cpu-model-expansion",
	537	NULL, test_query_cpu_model_expansion);
	538
	539	/*
	540	* For now we only run KVM specific tests with AArch64 QEMU in
	541	* order avoid attempting to run an AArch32 QEMU with KVM on
	542	* AArch64 hosts. That won't work and isn't easy to detect.
	543	*/
	544	if (g_str_equal(qtest_get_arch(), "aarch64")) {
	545	qtest_add_data_func("/arm/kvm/query-cpu-model-expansion",
	546	NULL, test_query_cpu_model_expansion_kvm);
	547	}
	548
0df9142d AJ	549	if (g_str_equal(qtest_get_arch(), "aarch64")) {
	550	qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-max-vq-8",
	551	NULL, sve_tests_sve_max_vq_8);
	552	qtest_add_data_func("/arm/max/query-cpu-model-expansion/sve-off",
	553	NULL, sve_tests_sve_off);
6fa8a379 AJ	554	qtest_add_data_func("/arm/kvm/query-cpu-model-expansion/sve-off",
6fa8a379 AJ	555	NULL, sve_tests_sve_off_kvm);
0df9142d AJ	556	}
0df9142d AJ	557
bd31b751 AJ	558	return g_test_run();
bd31b751 AJ	559	}