[qemu.git] / tests / cpu-plug-test.c

/*
 * QTest testcase for CPU plugging
 *
 * Copyright (c) 2015 SUSE Linux GmbH
 *
 * 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-common.h"
#include "libqtest.h"
#include "qapi/qmp/qdict.h"

struct PlugTestData {
    char *machine;
    const char *cpu_model;
    char *device_model;
    unsigned sockets;
    unsigned cores;
    unsigned threads;
    unsigned maxcpus;
};
typedef struct PlugTestData PlugTestData;

static void test_plug_with_cpu_add(gconstpointer data)
{
    const PlugTestData *s = data;
    char *args;
    QDict *response;
    unsigned int i;

    args = g_strdup_printf("-machine %s -cpu %s "
                           "-smp sockets=%u,cores=%u,threads=%u,maxcpus=%u",
                           s->machine, s->cpu_model,
                           s->sockets, s->cores, s->threads, s->maxcpus);
    qtest_start(args);

    for (i = s->sockets * s->cores * s->threads; i < s->maxcpus; i++) {
        response = qmp("{ 'execute': 'cpu-add',"
                       "  'arguments': { 'id': %d } }", i);
        g_assert(response);
        g_assert(!qdict_haskey(response, "error"));
        qobject_unref(response);
    }

    qtest_end();
    g_free(args);
}

static void test_plug_without_cpu_add(gconstpointer data)
{
    const PlugTestData *s = data;
    char *args;
    QDict *response;

    args = g_strdup_printf("-machine %s -cpu %s "
                           "-smp sockets=%u,cores=%u,threads=%u,maxcpus=%u",
                           s->machine, s->cpu_model,
                           s->sockets, s->cores, s->threads, s->maxcpus);
    qtest_start(args);

    response = qmp("{ 'execute': 'cpu-add',"
                   "  'arguments': { 'id': %d } }",
                   s->sockets * s->cores * s->threads);
    g_assert(response);
    g_assert(qdict_haskey(response, "error"));
    qobject_unref(response);

    qtest_end();
    g_free(args);
}

static void test_plug_with_device_add_x86(gconstpointer data)
{
    const PlugTestData *td = data;
    char *args;
    unsigned int s, c, t;

    args = g_strdup_printf("-machine %s -cpu %s "
                           "-smp sockets=%u,cores=%u,threads=%u,maxcpus=%u",
                           td->machine, td->cpu_model,
                           td->sockets, td->cores, td->threads, td->maxcpus);
    qtest_start(args);

    for (s = td->sockets; s < td->maxcpus / td->cores / td->threads; s++) {
        for (c = 0; c < td->cores; c++) {
            for (t = 0; t < td->threads; t++) {
                char *id = g_strdup_printf("id-%i-%i-%i", s, c, t);
                qtest_qmp_device_add(td->device_model, id,
                                     "{'socket-id':%u, 'core-id':%u,"
                                     " 'thread-id':%u}",
                                     s, c, t);
                g_free(id);
            }
        }
    }

    qtest_end();
    g_free(args);
}

static void test_plug_with_device_add_coreid(gconstpointer data)
{
    const PlugTestData *td = data;
    char *args;
    unsigned int c;

    args = g_strdup_printf("-machine %s -cpu %s "
                           "-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u",
                           td->machine, td->cpu_model,
                           td->sockets, td->cores, td->threads, td->maxcpus);
    qtest_start(args);

    for (c = td->cores; c < td->maxcpus / td->sockets / td->threads; c++) {
        char *id = g_strdup_printf("id-%i", c);
        qtest_qmp_device_add(td->device_model, id, "{'core-id':%u}", c);
        g_free(id);
    }

    qtest_end();
    g_free(args);
}

static void test_data_free(gpointer data)
{
    PlugTestData *pc = data;

    g_free(pc->machine);
    g_free(pc->device_model);
    g_free(pc);
}

static void add_pc_test_case(const char *mname)
{
    char *path;
    PlugTestData *data;

    if (!g_str_has_prefix(mname, "pc-")) {
        return;
    }
    data = g_new(PlugTestData, 1);
    data->machine = g_strdup(mname);
    data->cpu_model = "Haswell"; /* 1.3+ theoretically */
    data->device_model = g_strdup_printf("%s-%s-cpu", data->cpu_model,
                                         qtest_get_arch());
    data->sockets = 1;
    data->cores = 3;
    data->threads = 2;
    data->maxcpus = data->sockets * data->cores * data->threads * 2;
    if (g_str_has_suffix(mname, "-1.4") ||
        (strcmp(mname, "pc-1.3") == 0) ||
        (strcmp(mname, "pc-1.2") == 0) ||
        (strcmp(mname, "pc-1.1") == 0) ||
        (strcmp(mname, "pc-1.0") == 0) ||
        (strcmp(mname, "pc-0.15") == 0) ||
        (strcmp(mname, "pc-0.14") == 0) ||
        (strcmp(mname, "pc-0.13") == 0) ||
        (strcmp(mname, "pc-0.12") == 0) ||
        (strcmp(mname, "pc-0.11") == 0) ||
        (strcmp(mname, "pc-0.10") == 0)) {
        path = g_strdup_printf("cpu-plug/%s/init/%ux%ux%u&maxcpus=%u",
                               mname, data->sockets, data->cores,
                               data->threads, data->maxcpus);
        qtest_add_data_func_full(path, data, test_plug_without_cpu_add,
                                 test_data_free);
        g_free(path);
    } else {
        PlugTestData *data2 = g_memdup(data, sizeof(PlugTestData));

        data2->machine = g_strdup(data->machine);
        data2->device_model = g_strdup(data->device_model);

        path = g_strdup_printf("cpu-plug/%s/cpu-add/%ux%ux%u&maxcpus=%u",
                               mname, data->sockets, data->cores,
                               data->threads, data->maxcpus);
        qtest_add_data_func_full(path, data, test_plug_with_cpu_add,
                                 test_data_free);
        g_free(path);
        path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
                               mname, data2->sockets, data2->cores,
                               data2->threads, data2->maxcpus);
        qtest_add_data_func_full(path, data2, test_plug_with_device_add_x86,
                                 test_data_free);
        g_free(path);
    }
}

static void add_pseries_test_case(const char *mname)
{
    char *path;
    PlugTestData *data;

    if (!g_str_has_prefix(mname, "pseries-") ||
        (g_str_has_prefix(mname, "pseries-2.") && atoi(&mname[10]) < 7)) {
        return;
    }
    data = g_new(PlugTestData, 1);
    data->machine = g_strdup(mname);
    data->cpu_model = "power8_v2.0";
    data->device_model = g_strdup("power8_v2.0-spapr-cpu-core");
    data->sockets = 2;
    data->cores = 3;
    data->threads = 1;
    data->maxcpus = data->sockets * data->cores * data->threads * 2;

    path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
                           mname, data->sockets, data->cores,
                           data->threads, data->maxcpus);
    qtest_add_data_func_full(path, data, test_plug_with_device_add_coreid,
                             test_data_free);
    g_free(path);
}

static void add_s390x_test_case(const char *mname)
{
    char *path;
    PlugTestData *data, *data2;

    if (!g_str_has_prefix(mname, "s390-ccw-virtio-")) {
        return;
    }

    data = g_new(PlugTestData, 1);
    data->machine = g_strdup(mname);
    data->cpu_model = "qemu";
    data->device_model = g_strdup("qemu-s390x-cpu");
    data->sockets = 1;
    data->cores = 3;
    data->threads = 1;
    data->maxcpus = data->sockets * data->cores * data->threads * 2;

    data2 = g_memdup(data, sizeof(PlugTestData));
    data2->machine = g_strdup(data->machine);
    data2->device_model = g_strdup(data->device_model);

    path = g_strdup_printf("cpu-plug/%s/cpu-add/%ux%ux%u&maxcpus=%u",
                           mname, data->sockets, data->cores,
                           data->threads, data->maxcpus);
    qtest_add_data_func_full(path, data, test_plug_with_cpu_add,
                             test_data_free);
    g_free(path);

    path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
                           mname, data2->sockets, data2->cores,
                           data2->threads, data2->maxcpus);
    qtest_add_data_func_full(path, data2, test_plug_with_device_add_coreid,
                             test_data_free);
    g_free(path);
}

int main(int argc, char **argv)
{
    const char *arch = qtest_get_arch();

    g_test_init(&argc, &argv, NULL);

    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
        qtest_cb_for_every_machine(add_pc_test_case, g_test_quick());
    } else if (g_str_equal(arch, "ppc64")) {
        qtest_cb_for_every_machine(add_pseries_test_case, g_test_quick());
    } else if (g_str_equal(arch, "s390x")) {
        qtest_cb_for_every_machine(add_s390x_test_case, g_test_quick());
    }

    return g_test_run();
}
Commit	Line	Data
7fe55c3c	1	/*
152e0393	2	* QTest testcase for CPU plugging
7fe55c3c AF	3	*
	4	* Copyright (c) 2015 SUSE Linux GmbH
	5	*
	6	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	7	* See the COPYING file in the top-level directory.
	8	*/
	9
681c28a3	10	#include "qemu/osdep.h"
7fe55c3c AF	11
	12	#include "qemu-common.h"
	13	#include "libqtest.h"
452fcdbc	14	#include "qapi/qmp/qdict.h"
7fe55c3c	15
152e0393	16	struct PlugTestData {
34e46f60	17	char *machine;
7fe55c3c	18	const char *cpu_model;
80b8c0be	19	char *device_model;
7fe55c3c AF	20	unsigned sockets;
	21	unsigned cores;
	22	unsigned threads;
	23	unsigned maxcpus;
	24	};
152e0393	25	typedef struct PlugTestData PlugTestData;
7fe55c3c	26
152e0393	27	static void test_plug_with_cpu_add(gconstpointer data)
7fe55c3c	28	{
152e0393	29	const PlugTestData *s = data;
7fe55c3c AF	30	char *args;
	31	QDict *response;
	32	unsigned int i;
	33
	34	args = g_strdup_printf("-machine %s -cpu %s "
	35	"-smp sockets=%u,cores=%u,threads=%u,maxcpus=%u",
	36	s->machine, s->cpu_model,
	37	s->sockets, s->cores, s->threads, s->maxcpus);
	38	qtest_start(args);
	39
	40	for (i = s->sockets * s->cores * s->threads; i < s->maxcpus; i++) {
	41	response = qmp("{ 'execute': 'cpu-add',"
	42	" 'arguments': { 'id': %d } }", i);
	43	g_assert(response);
	44	g_assert(!qdict_haskey(response, "error"));
cb3e7f08	45	qobject_unref(response);
7fe55c3c AF	46	}
	47
	48	qtest_end();
	49	g_free(args);
	50	}
	51
152e0393	52	static void test_plug_without_cpu_add(gconstpointer data)
7fe55c3c	53	{
152e0393	54	const PlugTestData *s = data;
7fe55c3c AF	55	char *args;
	56	QDict *response;
	57
	58	args = g_strdup_printf("-machine %s -cpu %s "
	59	"-smp sockets=%u,cores=%u,threads=%u,maxcpus=%u",
	60	s->machine, s->cpu_model,
	61	s->sockets, s->cores, s->threads, s->maxcpus);
	62	qtest_start(args);
	63
	64	response = qmp("{ 'execute': 'cpu-add',"
	65	" 'arguments': { 'id': %d } }",
	66	s->sockets * s->cores * s->threads);
	67	g_assert(response);
	68	g_assert(qdict_haskey(response, "error"));
cb3e7f08	69	qobject_unref(response);
7fe55c3c AF	70
	71	qtest_end();
	72	g_free(args);
	73	}
	74
80b8c0be TH	75	static void test_plug_with_device_add_x86(gconstpointer data)
	76	{
	77	const PlugTestData *td = data;
	78	char *args;
	79	unsigned int s, c, t;
	80
	81	args = g_strdup_printf("-machine %s -cpu %s "
	82	"-smp sockets=%u,cores=%u,threads=%u,maxcpus=%u",
	83	td->machine, td->cpu_model,
	84	td->sockets, td->cores, td->threads, td->maxcpus);
	85	qtest_start(args);
	86
	87	for (s = td->sockets; s < td->maxcpus / td->cores / td->threads; s++) {
	88	for (c = 0; c < td->cores; c++) {
	89	for (t = 0; t < td->threads; t++) {
	90	char *id = g_strdup_printf("id-%i-%i-%i", s, c, t);
82cab70b MA	91	qtest_qmp_device_add(td->device_model, id,
	92	"{'socket-id':%u, 'core-id':%u,"
	93	" 'thread-id':%u}",
80b8c0be TH	94	s, c, t);
	95	g_free(id);
	96	}
	97	}
	98	}
	99
	100	qtest_end();
	101	g_free(args);
	102	}
	103
73a7d31e TH	104	static void test_plug_with_device_add_coreid(gconstpointer data)
	105	{
	106	const PlugTestData *td = data;
	107	char *args;
	108	unsigned int c;
	109
	110	args = g_strdup_printf("-machine %s -cpu %s "
	111	"-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u",
	112	td->machine, td->cpu_model,
	113	td->sockets, td->cores, td->threads, td->maxcpus);
	114	qtest_start(args);
	115
	116	for (c = td->cores; c < td->maxcpus / td->sockets / td->threads; c++) {
	117	char *id = g_strdup_printf("id-%i", c);
82cab70b	118	qtest_qmp_device_add(td->device_model, id, "{'core-id':%u}", c);
73a7d31e TH	119	g_free(id);
	120	}
	121
	122	qtest_end();
	123	g_free(args);
	124	}
	125
34e46f60 MAL	126	static void test_data_free(gpointer data)
34e46f60 MAL	127	{
152e0393	128	PlugTestData *pc = data;
34e46f60 MAL	129
34e46f60 MAL	130	g_free(pc->machine);
80b8c0be	131	g_free(pc->device_model);
34e46f60 MAL	132	g_free(pc);
	133	}
	134
02ef6e87	135	static void add_pc_test_case(const char *mname)
7fe55c3c	136	{
34e46f60	137	char *path;
152e0393	138	PlugTestData *data;
7fe55c3c	139
02ef6e87 TH	140	if (!g_str_has_prefix(mname, "pc-")) {
	141	return;
	142	}
152e0393	143	data = g_new(PlugTestData, 1);
02ef6e87 TH	144	data->machine = g_strdup(mname);
02ef6e87 TH	145	data->cpu_model = "Haswell"; /* 1.3+ theoretically */
80b8c0be TH	146	data->device_model = g_strdup_printf("%s-%s-cpu", data->cpu_model,
80b8c0be TH	147	qtest_get_arch());
02ef6e87 TH	148	data->sockets = 1;
	149	data->cores = 3;
	150	data->threads = 2;
	151	data->maxcpus = data->sockets * data->cores * data->threads * 2;
	152	if (g_str_has_suffix(mname, "-1.4") \|\|
	153	(strcmp(mname, "pc-1.3") == 0) \|\|
	154	(strcmp(mname, "pc-1.2") == 0) \|\|
	155	(strcmp(mname, "pc-1.1") == 0) \|\|
	156	(strcmp(mname, "pc-1.0") == 0) \|\|
	157	(strcmp(mname, "pc-0.15") == 0) \|\|
	158	(strcmp(mname, "pc-0.14") == 0) \|\|
	159	(strcmp(mname, "pc-0.13") == 0) \|\|
	160	(strcmp(mname, "pc-0.12") == 0) \|\|
	161	(strcmp(mname, "pc-0.11") == 0) \|\|
	162	(strcmp(mname, "pc-0.10") == 0)) {
80b8c0be	163	path = g_strdup_printf("cpu-plug/%s/init/%ux%ux%u&maxcpus=%u",
02ef6e87 TH	164	mname, data->sockets, data->cores,
02ef6e87 TH	165	data->threads, data->maxcpus);
152e0393	166	qtest_add_data_func_full(path, data, test_plug_without_cpu_add,
02ef6e87 TH	167	test_data_free);
	168	g_free(path);
	169	} else {
80b8c0be TH	170	PlugTestData *data2 = g_memdup(data, sizeof(PlugTestData));
	171
	172	data2->machine = g_strdup(data->machine);
	173	data2->device_model = g_strdup(data->device_model);
	174
	175	path = g_strdup_printf("cpu-plug/%s/cpu-add/%ux%ux%u&maxcpus=%u",
02ef6e87 TH	176	mname, data->sockets, data->cores,
02ef6e87 TH	177	data->threads, data->maxcpus);
152e0393	178	qtest_add_data_func_full(path, data, test_plug_with_cpu_add,
02ef6e87 TH	179	test_data_free);
02ef6e87 TH	180	g_free(path);
80b8c0be TH	181	path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
	182	mname, data2->sockets, data2->cores,
	183	data2->threads, data2->maxcpus);
	184	qtest_add_data_func_full(path, data2, test_plug_with_device_add_x86,
	185	test_data_free);
	186	g_free(path);
7fe55c3c	187	}
7fe55c3c AF	188	}
7fe55c3c AF	189
73a7d31e TH	190	static void add_pseries_test_case(const char *mname)
	191	{
	192	char *path;
	193	PlugTestData *data;
	194
	195	if (!g_str_has_prefix(mname, "pseries-") \|\|
	196	(g_str_has_prefix(mname, "pseries-2.") && atoi(&mname[10]) < 7)) {
	197	return;
	198	}
	199	data = g_new(PlugTestData, 1);
	200	data->machine = g_strdup(mname);
	201	data->cpu_model = "power8_v2.0";
	202	data->device_model = g_strdup("power8_v2.0-spapr-cpu-core");
	203	data->sockets = 2;
	204	data->cores = 3;
	205	data->threads = 1;
	206	data->maxcpus = data->sockets * data->cores * data->threads * 2;
	207
	208	path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
	209	mname, data->sockets, data->cores,
	210	data->threads, data->maxcpus);
	211	qtest_add_data_func_full(path, data, test_plug_with_device_add_coreid,
	212	test_data_free);
	213	g_free(path);
	214	}
	215
7d8b00fa TH	216	static void add_s390x_test_case(const char *mname)
	217	{
	218	char *path;
	219	PlugTestData data, data2;
	220
	221	if (!g_str_has_prefix(mname, "s390-ccw-virtio-")) {
	222	return;
	223	}
	224
	225	data = g_new(PlugTestData, 1);
	226	data->machine = g_strdup(mname);
	227	data->cpu_model = "qemu";
	228	data->device_model = g_strdup("qemu-s390x-cpu");
	229	data->sockets = 1;
	230	data->cores = 3;
	231	data->threads = 1;
	232	data->maxcpus = data->sockets * data->cores * data->threads * 2;
	233
	234	data2 = g_memdup(data, sizeof(PlugTestData));
	235	data2->machine = g_strdup(data->machine);
	236	data2->device_model = g_strdup(data->device_model);
	237
	238	path = g_strdup_printf("cpu-plug/%s/cpu-add/%ux%ux%u&maxcpus=%u",
	239	mname, data->sockets, data->cores,
	240	data->threads, data->maxcpus);
	241	qtest_add_data_func_full(path, data, test_plug_with_cpu_add,
	242	test_data_free);
	243	g_free(path);
	244
	245	path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
	246	mname, data2->sockets, data2->cores,
	247	data2->threads, data2->maxcpus);
	248	qtest_add_data_func_full(path, data2, test_plug_with_device_add_coreid,
	249	test_data_free);
	250	g_free(path);
	251	}
	252
7fe55c3c AF	253	int main(int argc, char **argv)
	254	{
	255	const char *arch = qtest_get_arch();
	256
	257	g_test_init(&argc, &argv, NULL);
	258
	259	if (strcmp(arch, "i386") == 0 \|\| strcmp(arch, "x86_64") == 0) {
1f4a0d81	260	qtest_cb_for_every_machine(add_pc_test_case, g_test_quick());
73a7d31e	261	} else if (g_str_equal(arch, "ppc64")) {
1f4a0d81	262	qtest_cb_for_every_machine(add_pseries_test_case, g_test_quick());
7d8b00fa	263	} else if (g_str_equal(arch, "s390x")) {
1f4a0d81	264	qtest_cb_for_every_machine(add_s390x_test_case, g_test_quick());
7fe55c3c AF	265	}
	266
	267	return g_test_run();
	268	}