1#include "qemu/osdep.h"
2#include <glib/gstdio.h>
3#include <gio/gio.h>
4#include "libqos/libqtest.h"
5#include "qemu-common.h"
6#include "dbus-vmstate1.h"
7#include "migration-helpers.h"
8
9static char *workdir;
10
11typedef struct TestServerId {
12 const char *name;
13 const char *data;
14 size_t size;
15} TestServerId;
16
17static const TestServerId idA = {
18 "idA", "I'am\0idA!", sizeof("I'am\0idA!")
19};
20
21static const TestServerId idB = {
22 "idB", "I'am\0idB!", sizeof("I'am\0idB!")
23};
24
25typedef struct TestServer {
26 const TestServerId *id;
27 bool save_called;
28 bool load_called;
29} TestServer;
30
31typedef struct Test {
32 const char *id_list;
33 bool migrate_fail;
34 bool without_dst_b;
35 TestServer srcA;
36 TestServer dstA;
37 TestServer srcB;
38 TestServer dstB;
39 GMainLoop *loop;
40 QTestState *src_qemu;
41} Test;
42
43static gboolean
44vmstate_load(VMState1 *object, GDBusMethodInvocation *invocation,
45 const gchar *arg_data, gpointer user_data)
46{
47 TestServer *h = user_data;
48 g_autoptr(GVariant) var = NULL;
49 GVariant *args;
50 const uint8_t *data;
51 size_t size;
52
53 args = g_dbus_method_invocation_get_parameters(invocation);
54 var = g_variant_get_child_value(args, 0);
55 data = g_variant_get_fixed_array(var, &size, sizeof(char));
56 g_assert_cmpuint(size, ==, h->id->size);
57 g_assert(!memcmp(data, h->id->data, h->id->size));
58 h->load_called = true;
59
60 g_dbus_method_invocation_return_value(invocation, g_variant_new("()"));
61 return TRUE;
62}
63
64static gboolean
65vmstate_save(VMState1 *object, GDBusMethodInvocation *invocation,
66 gpointer user_data)
67{
68 TestServer *h = user_data;
69 GVariant *var;
70
71 var = g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
72 h->id->data, h->id->size, sizeof(char));
73 g_dbus_method_invocation_return_value(invocation,
74 g_variant_new("(@ay)", var));
75 h->save_called = true;
76
77 return TRUE;
78}
79
80typedef struct WaitNamed {
81 GMainLoop *loop;
82 bool named;
83} WaitNamed;
84
85static void
86named_cb(GDBusConnection *connection,
87 const gchar *name,
88 gpointer user_data)
89{
90 WaitNamed *t = user_data;
91
92 t->named = true;
93 g_main_loop_quit(t->loop);
94}
95
96static GDBusConnection *
97get_connection(Test *test, guint *ownid)
98{
99 g_autofree gchar *addr = NULL;
100 WaitNamed *wait;
101 GError *err = NULL;
102 GDBusConnection *c;
103
104 wait = g_new0(WaitNamed, 1);
105 wait->loop = test->loop;
106 addr = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SESSION, NULL, &err);
107 g_assert_no_error(err);
108
109 c = g_dbus_connection_new_for_address_sync(
110 addr,
111 G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION |
112 G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
113 NULL, NULL, &err);
114 g_assert_no_error(err);
115 *ownid = g_bus_own_name_on_connection(c, "org.qemu.VMState1",
116 G_BUS_NAME_OWNER_FLAGS_NONE,
117 named_cb, named_cb, wait, g_free);
118 if (!wait->named) {
119 g_main_loop_run(wait->loop);
120 }
121
122 return c;
123}
124
125static GDBusObjectManagerServer *
126get_server(GDBusConnection *conn, TestServer *s, const TestServerId *id)
127{
128 g_autoptr(GDBusObjectSkeleton) sk = NULL;
129 g_autoptr(VMState1Skeleton) v = NULL;
130 GDBusObjectManagerServer *os;
131
132 s->id = id;
133 os = g_dbus_object_manager_server_new("/org/qemu");
134 sk = g_dbus_object_skeleton_new("/org/qemu/VMState1");
135
136 v = VMSTATE1_SKELETON(vmstate1_skeleton_new());
137 g_object_set(v, "id", id->name, NULL);
138
139 g_signal_connect(v, "handle-load", G_CALLBACK(vmstate_load), s);
140 g_signal_connect(v, "handle-save", G_CALLBACK(vmstate_save), s);
141
142 g_dbus_object_skeleton_add_interface(sk, G_DBUS_INTERFACE_SKELETON(v));
143 g_dbus_object_manager_server_export(os, sk);
144 g_dbus_object_manager_server_set_connection(os, conn);
145
146 return os;
147}
148
149static void
150set_id_list(Test *test, QTestState *s)
151{
152 if (!test->id_list) {
153 return;
154 }
155
156 g_assert(!qmp_rsp_is_err(qtest_qmp(s,
157 "{ 'execute': 'qom-set', 'arguments': "
158 "{ 'path': '/objects/dv', 'property': 'id-list', 'value': %s } }",
159 test->id_list)));
160}
161
162static gpointer
163dbus_vmstate_thread(gpointer data)
164{
165 GMainLoop *loop = data;
166
167 g_main_loop_run(loop);
168
169 return NULL;
170}
171
172static void
173test_dbus_vmstate(Test *test)
174{
175 g_autofree char *src_qemu_args = NULL;
176 g_autofree char *dst_qemu_args = NULL;
177 g_autoptr(GTestDBus) srcbus = NULL;
178 g_autoptr(GTestDBus) dstbus = NULL;
179 g_autoptr(GDBusConnection) srcconnA = NULL;
180 g_autoptr(GDBusConnection) srcconnB = NULL;
181 g_autoptr(GDBusConnection) dstconnA = NULL;
182 g_autoptr(GDBusConnection) dstconnB = NULL;
183 g_autoptr(GDBusObjectManagerServer) srcserverA = NULL;
184 g_autoptr(GDBusObjectManagerServer) srcserverB = NULL;
185 g_autoptr(GDBusObjectManagerServer) dstserverA = NULL;
186 g_autoptr(GDBusObjectManagerServer) dstserverB = NULL;
187 g_auto(GStrv) srcaddr = NULL;
188 g_auto(GStrv) dstaddr = NULL;
189 g_autoptr(GThread) thread = NULL;
190 g_autoptr(GMainLoop) loop = NULL;
191 g_autofree char *uri = NULL;
192 QTestState *src_qemu = NULL, *dst_qemu = NULL;
193 guint ownsrcA, ownsrcB, owndstA, owndstB;
194
195 uri = g_strdup_printf("unix:%s/migsocket", workdir);
196
197 loop = g_main_loop_new(NULL, FALSE);
198 test->loop = loop;
199
200 srcbus = g_test_dbus_new(G_TEST_DBUS_NONE);
201 g_test_dbus_up(srcbus);
202 srcconnA = get_connection(test, &ownsrcA);
203 srcserverA = get_server(srcconnA, &test->srcA, &idA);
204 srcconnB = get_connection(test, &ownsrcB);
205 srcserverB = get_server(srcconnB, &test->srcB, &idB);
206
207
208 srcaddr = g_strsplit(g_test_dbus_get_bus_address(srcbus), ",", 2);
209 src_qemu_args =
210 g_strdup_printf("-object dbus-vmstate,id=dv,addr=%s", srcaddr[0]);
211
212 dstbus = g_test_dbus_new(G_TEST_DBUS_NONE);
213 g_test_dbus_up(dstbus);
214 dstconnA = get_connection(test, &owndstA);
215 dstserverA = get_server(dstconnA, &test->dstA, &idA);
216 if (!test->without_dst_b) {
217 dstconnB = get_connection(test, &owndstB);
218 dstserverB = get_server(dstconnB, &test->dstB, &idB);
219 }
220
221 dstaddr = g_strsplit(g_test_dbus_get_bus_address(dstbus), ",", 2);
222 dst_qemu_args =
223 g_strdup_printf("-object dbus-vmstate,id=dv,addr=%s -incoming %s",
224 dstaddr[0], uri);
225
226 src_qemu = qtest_init(src_qemu_args);
227 dst_qemu = qtest_init(dst_qemu_args);
228 set_id_list(test, src_qemu);
229 set_id_list(test, dst_qemu);
230
231 thread = g_thread_new("dbus-vmstate-thread", dbus_vmstate_thread, loop);
232
233 migrate_qmp(src_qemu, uri, "{}");
234 test->src_qemu = src_qemu;
235 if (test->migrate_fail) {
236 wait_for_migration_fail(src_qemu, true);
237 qtest_set_expected_status(dst_qemu, 1);
238 } else {
239 wait_for_migration_complete(src_qemu);
240 }
241
242 qtest_quit(dst_qemu);
243 qtest_quit(src_qemu);
244 g_bus_unown_name(ownsrcA);
245 g_bus_unown_name(ownsrcB);
246 g_bus_unown_name(owndstA);
247 if (!test->without_dst_b) {
248 g_bus_unown_name(owndstB);
249 }
250
251 g_main_loop_quit(test->loop);
252}
253
254static void
255check_not_migrated(TestServer *s, TestServer *d)
256{
257 assert(!s->save_called);
258 assert(!s->load_called);
259 assert(!d->save_called);
260 assert(!d->load_called);
261}
262
263static void
264check_migrated(TestServer *s, TestServer *d)
265{
266 assert(s->save_called);
267 assert(!s->load_called);
268 assert(!d->save_called);
269 assert(d->load_called);
270}
271
272static void
273test_dbus_vmstate_without_list(void)
274{
275 Test test = { 0, };
276
277 test_dbus_vmstate(&test);
278
279 check_migrated(&test.srcA, &test.dstA);
280 check_migrated(&test.srcB, &test.dstB);
281}
282
283static void
284test_dbus_vmstate_with_list(void)
285{
286 Test test = { .id_list = "idA,idB" };
287
288 test_dbus_vmstate(&test);
289
290 check_migrated(&test.srcA, &test.dstA);
291 check_migrated(&test.srcB, &test.dstB);
292}
293
294static void
295test_dbus_vmstate_only_a(void)
296{
297 Test test = { .id_list = "idA" };
298
299 test_dbus_vmstate(&test);
300
301 check_migrated(&test.srcA, &test.dstA);
302 check_not_migrated(&test.srcB, &test.dstB);
303}
304
305static void
306test_dbus_vmstate_missing_src(void)
307{
308 Test test = { .id_list = "idA,idC", .migrate_fail = true };
309
310
311 if (g_test_subprocess()) {
312 test_dbus_vmstate(&test);
313 check_not_migrated(&test.srcA, &test.dstA);
314 check_not_migrated(&test.srcB, &test.dstB);
315 return;
316 }
317
318 g_test_trap_subprocess(NULL, 0, 0);
319 g_test_trap_assert_passed();
320}
321
322static void
323test_dbus_vmstate_missing_dst(void)
324{
325 Test test = { .id_list = "idA,idB",
326 .without_dst_b = true,
327 .migrate_fail = true };
328
329
330 if (g_test_subprocess()) {
331 test_dbus_vmstate(&test);
332 assert(test.srcA.save_called);
333 assert(test.srcB.save_called);
334 assert(!test.dstB.save_called);
335 return;
336 }
337
338 g_test_trap_subprocess(NULL, 0, 0);
339 g_test_trap_assert_passed();
340}
341
342int
343main(int argc, char **argv)
344{
345 GError *err = NULL;
346 g_autofree char *dbus_daemon = NULL;
347 int ret;
348
349 dbus_daemon = g_build_filename(G_STRINGIFY(SRCDIR),
350 "tests",
351 "dbus-vmstate-daemon.sh",
352 NULL);
353 g_setenv("G_TEST_DBUS_DAEMON", dbus_daemon, true);
354
355 g_test_init(&argc, &argv, NULL);
356
357 workdir = g_dir_make_tmp("dbus-vmstate-test-XXXXXX", &err);
358 if (!workdir) {
359 g_error("Unable to create temporary dir: %s\n", err->message);
360 exit(1);
361 }
362
363 g_setenv("DBUS_VMSTATE_TEST_TMPDIR", workdir, true);
364
365 qtest_add_func("/dbus-vmstate/without-list",
366 test_dbus_vmstate_without_list);
367 qtest_add_func("/dbus-vmstate/with-list",
368 test_dbus_vmstate_with_list);
369 qtest_add_func("/dbus-vmstate/only-a",
370 test_dbus_vmstate_only_a);
371 qtest_add_func("/dbus-vmstate/missing-src",
372 test_dbus_vmstate_missing_src);
373 qtest_add_func("/dbus-vmstate/missing-dst",
374 test_dbus_vmstate_missing_dst);
375
376 ret = g_test_run();
377
378 rmdir(workdir);
379 g_free(workdir);
380
381 return ret;
382}
383
