[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 1,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 = 1; 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 1,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;
    QTestState *qts;

    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);
    qts = qtest_init(args);

    for (s = 1; s < td->sockets; 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(qts, td->device_model, id,
                                     "{'socket-id':%u, 'core-id':%u,"
                                     " 'thread-id':%u}",
                                     s, c, t);
                g_free(id);
            }
        }
    }

    qtest_quit(qts);
    g_free(args);
}

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

    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);
    qts = qtest_init(args);

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

    qtest_quit(qts);
    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;
    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)) {
        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;

    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;

    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 "
bc1fb850	35	"-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u",
7fe55c3c AF	36	s->machine, s->cpu_model,
	37	s->sockets, s->cores, s->threads, s->maxcpus);
	38	qtest_start(args);
	39
bc1fb850	40	for (i = 1; i < s->maxcpus; i++) {
7fe55c3c AF	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 "
bc1fb850	59	"-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u",
7fe55c3c AF	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;
e5758de4	80	QTestState *qts;
80b8c0be TH	81
80b8c0be TH	82	args = g_strdup_printf("-machine %s -cpu %s "
bc1fb850	83	"-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u",
80b8c0be TH	84	td->machine, td->cpu_model,
80b8c0be TH	85	td->sockets, td->cores, td->threads, td->maxcpus);
e5758de4	86	qts = qtest_init(args);
80b8c0be	87
bc1fb850	88	for (s = 1; s < td->sockets; s++) {
80b8c0be TH	89	for (c = 0; c < td->cores; c++) {
	90	for (t = 0; t < td->threads; t++) {
	91	char *id = g_strdup_printf("id-%i-%i-%i", s, c, t);
e5758de4	92	qtest_qmp_device_add(qts, td->device_model, id,
82cab70b MA	93	"{'socket-id':%u, 'core-id':%u,"
82cab70b MA	94	" 'thread-id':%u}",
80b8c0be TH	95	s, c, t);
	96	g_free(id);
	97	}
	98	}
	99	}
	100
e5758de4	101	qtest_quit(qts);
80b8c0be TH	102	g_free(args);
	103	}
	104
73a7d31e TH	105	static void test_plug_with_device_add_coreid(gconstpointer data)
	106	{
	107	const PlugTestData *td = data;
	108	char *args;
	109	unsigned int c;
e5758de4	110	QTestState *qts;
73a7d31e TH	111
	112	args = g_strdup_printf("-machine %s -cpu %s "
	113	"-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u",
	114	td->machine, td->cpu_model,
	115	td->sockets, td->cores, td->threads, td->maxcpus);
e5758de4	116	qts = qtest_init(args);
73a7d31e	117
bc1fb850	118	for (c = 1; c < td->cores; c++) {
73a7d31e	119	char *id = g_strdup_printf("id-%i", c);
e5758de4 TH	120	qtest_qmp_device_add(qts, td->device_model, id,
e5758de4 TH	121	"{'core-id':%u}", c);
73a7d31e TH	122	g_free(id);
	123	}
	124
e5758de4	125	qtest_quit(qts);
73a7d31e TH	126	g_free(args);
	127	}
	128
34e46f60 MAL	129	static void test_data_free(gpointer data)
34e46f60 MAL	130	{
152e0393	131	PlugTestData *pc = data;
34e46f60 MAL	132
34e46f60 MAL	133	g_free(pc->machine);
80b8c0be	134	g_free(pc->device_model);
34e46f60 MAL	135	g_free(pc);
	136	}
	137
02ef6e87	138	static void add_pc_test_case(const char *mname)
7fe55c3c	139	{
34e46f60	140	char *path;
152e0393	141	PlugTestData *data;
7fe55c3c	142
02ef6e87 TH	143	if (!g_str_has_prefix(mname, "pc-")) {
	144	return;
	145	}
152e0393	146	data = g_new(PlugTestData, 1);
02ef6e87 TH	147	data->machine = g_strdup(mname);
02ef6e87 TH	148	data->cpu_model = "Haswell"; /* 1.3+ theoretically */
80b8c0be TH	149	data->device_model = g_strdup_printf("%s-%s-cpu", data->cpu_model,
80b8c0be TH	150	qtest_get_arch());
02ef6e87 TH	151	data->sockets = 1;
	152	data->cores = 3;
	153	data->threads = 2;
bc1fb850	154	data->maxcpus = data->sockets * data->cores * data->threads;
02ef6e87 TH	155	if (g_str_has_suffix(mname, "-1.4") \|\|
	156	(strcmp(mname, "pc-1.3") == 0) \|\|
	157	(strcmp(mname, "pc-1.2") == 0) \|\|
	158	(strcmp(mname, "pc-1.1") == 0) \|\|
	159	(strcmp(mname, "pc-1.0") == 0) \|\|
	160	(strcmp(mname, "pc-0.15") == 0) \|\|
	161	(strcmp(mname, "pc-0.14") == 0) \|\|
	162	(strcmp(mname, "pc-0.13") == 0) \|\|
cc425b5d	163	(strcmp(mname, "pc-0.12") == 0)) {
80b8c0be	164	path = g_strdup_printf("cpu-plug/%s/init/%ux%ux%u&maxcpus=%u",
02ef6e87 TH	165	mname, data->sockets, data->cores,
02ef6e87 TH	166	data->threads, data->maxcpus);
152e0393	167	qtest_add_data_func_full(path, data, test_plug_without_cpu_add,
02ef6e87 TH	168	test_data_free);
	169	g_free(path);
	170	} else {
80b8c0be TH	171	PlugTestData *data2 = g_memdup(data, sizeof(PlugTestData));
	172
	173	data2->machine = g_strdup(data->machine);
	174	data2->device_model = g_strdup(data->device_model);
	175
	176	path = g_strdup_printf("cpu-plug/%s/cpu-add/%ux%ux%u&maxcpus=%u",
02ef6e87 TH	177	mname, data->sockets, data->cores,
02ef6e87 TH	178	data->threads, data->maxcpus);
152e0393	179	qtest_add_data_func_full(path, data, test_plug_with_cpu_add,
02ef6e87 TH	180	test_data_free);
02ef6e87 TH	181	g_free(path);
80b8c0be TH	182	path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
	183	mname, data2->sockets, data2->cores,
	184	data2->threads, data2->maxcpus);
	185	qtest_add_data_func_full(path, data2, test_plug_with_device_add_x86,
	186	test_data_free);
	187	g_free(path);
7fe55c3c	188	}
7fe55c3c AF	189	}
7fe55c3c AF	190
73a7d31e TH	191	static void add_pseries_test_case(const char *mname)
	192	{
	193	char *path;
	194	PlugTestData *data;
	195
	196	if (!g_str_has_prefix(mname, "pseries-") \|\|
	197	(g_str_has_prefix(mname, "pseries-2.") && atoi(&mname[10]) < 7)) {
	198	return;
	199	}
	200	data = g_new(PlugTestData, 1);
	201	data->machine = g_strdup(mname);
	202	data->cpu_model = "power8_v2.0";
	203	data->device_model = g_strdup("power8_v2.0-spapr-cpu-core");
	204	data->sockets = 2;
	205	data->cores = 3;
	206	data->threads = 1;
bc1fb850	207	data->maxcpus = data->sockets * data->cores * data->threads;
73a7d31e TH	208
	209	path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
	210	mname, data->sockets, data->cores,
	211	data->threads, data->maxcpus);
	212	qtest_add_data_func_full(path, data, test_plug_with_device_add_coreid,
	213	test_data_free);
	214	g_free(path);
	215	}
	216
7d8b00fa TH	217	static void add_s390x_test_case(const char *mname)
	218	{
	219	char *path;
	220	PlugTestData data, data2;
	221
	222	if (!g_str_has_prefix(mname, "s390-ccw-virtio-")) {
	223	return;
	224	}
	225
	226	data = g_new(PlugTestData, 1);
	227	data->machine = g_strdup(mname);
	228	data->cpu_model = "qemu";
	229	data->device_model = g_strdup("qemu-s390x-cpu");
	230	data->sockets = 1;
	231	data->cores = 3;
	232	data->threads = 1;
bc1fb850	233	data->maxcpus = data->sockets * data->cores * data->threads;
7d8b00fa TH	234
	235	data2 = g_memdup(data, sizeof(PlugTestData));
	236	data2->machine = g_strdup(data->machine);
	237	data2->device_model = g_strdup(data->device_model);
	238
	239	path = g_strdup_printf("cpu-plug/%s/cpu-add/%ux%ux%u&maxcpus=%u",
	240	mname, data->sockets, data->cores,
	241	data->threads, data->maxcpus);
	242	qtest_add_data_func_full(path, data, test_plug_with_cpu_add,
	243	test_data_free);
	244	g_free(path);
	245
	246	path = g_strdup_printf("cpu-plug/%s/device-add/%ux%ux%u&maxcpus=%u",
	247	mname, data2->sockets, data2->cores,
	248	data2->threads, data2->maxcpus);
	249	qtest_add_data_func_full(path, data2, test_plug_with_device_add_coreid,
	250	test_data_free);
	251	g_free(path);
	252	}
	253
7fe55c3c AF	254	int main(int argc, char **argv)
	255	{
	256	const char *arch = qtest_get_arch();
	257
	258	g_test_init(&argc, &argv, NULL);
	259
	260	if (strcmp(arch, "i386") == 0 \|\| strcmp(arch, "x86_64") == 0) {
1f4a0d81	261	qtest_cb_for_every_machine(add_pc_test_case, g_test_quick());
73a7d31e	262	} else if (g_str_equal(arch, "ppc64")) {
1f4a0d81	263	qtest_cb_for_every_machine(add_pseries_test_case, g_test_quick());
7d8b00fa	264	} else if (g_str_equal(arch, "s390x")) {
1f4a0d81	265	qtest_cb_for_every_machine(add_s390x_test_case, g_test_quick());
7fe55c3c AF	266	}
	267
	268	return g_test_run();
	269	}